@wular/coder 0.4.6 → 0.4.8

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

@@ -0,0 +1,472 @@
+// @bun
+import {
+  devServerModuleHref,
+  registerServerRuntime
+} from "./index-912z4mfx.js";
+import {
+  pathToFileHref
+} from "./index-zedjt25v.js";
+import {
+  runWithRequest
+} from "./index-grta8ap3.js";
+import {
+  getProxyExtensions,
+  withRouteRuntime
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/routing/proxy.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+import {
+  copyMiddlewareHeaders,
+  forwardMiddlewareRequestHeaders,
+  getSetCookie,
+  NextResponse,
+  nextResponseMeta,
+  parseCookies,
+  requestCookieHeader,
+  toNextRequest
+} from "../../../src/api/server.ts";
+import { canonicalTrailingSlashPath, isBuildAssetPathname } from "../../../src/routing/href.ts";
+var proxyRewriteObserver;
+function setProxyRewriteObserver(observer) {
+  proxyRewriteObserver = observer;
+}
+var proxyRunObserver;
+function setProxyRunObserver(observer) {
+  proxyRunObserver = observer;
+}
+function wrapMiddleware(request, fn) {
+  return proxyRunObserver ? proxyRunObserver(request, fn) : fn();
+}
+var proxyExtensions = [".ts", ".tsx", ".js", ".jsx", ".mts"];
+function findProxyFile(config) {
+  return findProxyFiles(config)[0];
+}
+function proxyExternalLoadTarget(file) {
+  return path.basename(file).startsWith("proxy.") ? "client-ssr" : "edge";
+}
+function findProxyFiles(config, names = getProxyExtensions().names) {
+  const files = [];
+  for (const base of proxyBases(config)) {
+    for (const name of names) {
+      for (const extension of proxyExtensions) {
+        const file = path.join(base, `${name}${extension}`);
+        if (existsSync(file))
+          files.push(file);
+      }
+    }
+  }
+  return files;
+}
+async function validateProxyFiles(config) {
+  await getProxyExtensions().validateFiles(config);
+}
+function createProxyRunner(config, runnerOptions = {}) {
+  const { released } = runnerOptions;
+  const file = released ? released.file : findProxyFile(config);
+  const releasedMatchers = released?.config ? proxyMatchers(released.config) : undefined;
+  const runtimeReady = registerServerRuntime(config, file ? [file] : []);
+  runtimeReady.catch(() => {
+    return;
+  });
+  let moduleKey;
+  let modulePromise;
+  let matchers;
+  function proxyModule(options) {
+    const key = proxyModuleKey(options);
+    const load = () => runtimeReady.then(() => importProxyModule(config, file, options, runnerOptions));
+    if (key !== moduleKey) {
+      moduleKey = key;
+      modulePromise = load();
+      matchers = undefined;
+    }
+    return modulePromise ??= load();
+  }
+  const runner = async (request, options = {}) => {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith("/__pnext/") || !config.compat?.next && isBuildAssetPathname(url.pathname)) {
+      return;
+    }
+    if (!file)
+      return;
+    if (!matchers && proxyMatcherGateEnabled()) {
+      const staticMatchers = released ? releasedMatchers : await staticProxyMatchers(file);
+      if (staticMatchers && !matchesProxy(staticMatchers, url, request))
+        return;
+    }
+    const module = await proxyModule(options);
+    matchers ??= proxyMatchers(module.config);
+    if (!matchesProxy(matchers, url, request))
+      return;
+    request = await bufferProxyRequestBody(request, url.pathname);
+    const handlerExport = getProxyExtensions().handlerExport(module);
+    if (typeof handlerExport !== "function")
+      throw new Error(`${file} must export proxy or default`);
+    const handler = handlerExport;
+    const handlerRequest = getProxyExtensions().skipUrlNormalize() ? request : stripFlightHeaders(stripRscUnionQuery(request));
+    const nextRequest = toNextRequest(handlerRequest);
+    const proxyResponseHeaders = new Headers;
+    let response = await runWithRequest(nextRequest, () => withRouteRuntime("edge", () => wrapMiddleware(nextRequest, () => handler(nextRequest, {
+      waitUntil(promise) {}
+    }))), {}, { responseHeaders: proxyResponseHeaders });
+    const scopedCookies = getSetCookie(proxyResponseHeaders);
+    if (scopedCookies.length > 0) {
+      if (!response)
+        response = NextResponse.next();
+      for (const cookie of scopedCookies)
+        response.headers.append("set-cookie", cookie);
+    }
+    if (!response)
+      return { request };
+    response = await normalizeRedirectResponse(response, url, request.method, config);
+    const meta = nextResponseMeta(response);
+    if (!meta)
+      return response;
+    const forwardedRequest = forwardMiddlewareRequestHeaders(response, applyProxyCookies(applyRequestOverride(request, meta.requestHeaders), response));
+    if (meta.kind === "rewrite" && meta.url) {
+      let rewritten = rewriteRequest(forwardedRequest, meta.url);
+      const rewrittenUrl = new URL(rewritten.url);
+      if (rewrittenUrl.origin !== url.origin) {
+        const rscHash = url.searchParams.get("_rsc");
+        if (rscHash !== null && !rewrittenUrl.searchParams.has("_rsc")) {
+          rewrittenUrl.searchParams.set("_rsc", rscHash);
+          rewritten = new Request(rewrittenUrl, rewritten);
+        }
+        getProxyExtensions().onExternalRewrite(rewritten);
+        const externalHeaders = new Headers(rewritten.headers);
+        externalHeaders.delete("host");
+        const external = await fetch(new Request(rewritten, { headers: externalHeaders }));
+        const headers = new Headers(external.headers);
+        headers.delete("content-encoding");
+        headers.delete("content-length");
+        headers.delete("transfer-encoding");
+        const proxied = new Response(external.body, {
+          status: external.status,
+          statusText: external.statusText,
+          headers
+        });
+        copyMiddlewareHeaders(response, proxied);
+        return proxied;
+      }
+      if (rewrittenUrl.origin === url.origin) {
+        proxyRewriteObserver?.(url, rewrittenUrl);
+        if (request.headers.get("x-nextjs-data") === "1") {
+          response.headers.set("x-nextjs-rewrite", rewrittenUrl.href);
+        }
+      }
+      return { request: rewritten, response };
+    }
+    return { request: forwardedRequest, response };
+  };
+  runner.warm = (options = {}) => {
+    if (!file)
+      return;
+    proxyModule(options).catch(() => {
+      return;
+    });
+  };
+  return runner;
+}
+async function normalizeRedirectResponse(response, requestUrl, method, config) {
+  if (response.status < 300 || response.status >= 400)
+    return response;
+  const location = response.headers.get("location");
+  if (!location)
+    return response;
+  let target;
+  try {
+    target = new URL(location, requestUrl);
+  } catch {
+    return response;
+  }
+  if (target.origin === requestUrl.origin) {
+    if (!config.skipTrailingSlashRedirect && config.trailingSlash) {
+      target.pathname = canonicalTrailingSlashPath(target.pathname, true);
+    }
+  }
+  const destination = target.origin === requestUrl.origin ? `${target.pathname}${target.search}${target.hash}` : target.href;
+  const headers = new Headers(response.headers);
+  headers.set("location", destination);
+  const body = method.toUpperCase() === "HEAD" || response.body === null ? null : await response.arrayBuffer();
+  const synthesizeDestination = method.toUpperCase() !== "HEAD" && (!body || body.byteLength === 0);
+  if (synthesizeDestination)
+    headers.delete("content-length");
+  return new Response(synthesizeDestination ? destination : body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function formatBodyLimit(bytes) {
+  if (bytes >= 1024 * 1024 && bytes % (1024 * 1024) === 0)
+    return `${bytes / (1024 * 1024)}MB`;
+  if (bytes >= 1024 && bytes % 1024 === 0)
+    return `${bytes / 1024}KB`;
+  return `${bytes}B`;
+}
+async function bufferProxyRequestBody(request, pathname) {
+  if (request.method === "GET" || request.method === "HEAD" || !request.body)
+    return request;
+  const limit = getProxyExtensions().clientMaxBodySize();
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  const reader = request.body.getReader();
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    if (!truncated && total + value.byteLength > limit) {
+      const keep = limit - total;
+      if (keep > 0)
+        chunks.push(value.subarray(0, keep));
+      total = limit;
+      truncated = true;
+      continue;
+    }
+    if (!truncated) {
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  }
+  if (truncated) {
+    console.warn(`Request body exceeded ${formatBodyLimit(limit)} for ${pathname}`);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const headers = new Headers(request.headers);
+  headers.set("content-length", String(total));
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body,
+    duplex: "half"
+  });
+}
+function applyProxyResponse(response, proxyResponse) {
+  if (proxyResponse)
+    copyMiddlewareHeaders(proxyResponse, response);
+  return response;
+}
+function proxyRoutePatterns(config) {
+  const matcher = config?.matcher;
+  if (!matcher)
+    return ["^/(.*)$"];
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.map((item) => anchoredMatcherPattern(matcherSource(item)));
+}
+async function importProxyModule(config, file, options, runnerOptions) {
+  const href = options.dev ? await devServerModuleHref(config, file, options.devImportVersion ?? "dev", {
+    conditionTarget: "edge",
+    externalLoadTarget: proxyExternalLoadTarget(file),
+    reactServerLayer: true
+  }) : runnerOptions.compiledModuleHref ?? pathToFileHref(file);
+  return import(href);
+}
+function proxyBases(config) {
+  return config.appPath === path.join(config.root, "src", "app") ? [path.join(config.root, "src"), config.root] : [config.root];
+}
+function proxyMatcherGateEnabled() {
+  return process.env.PNEXT_PROXY_MATCHER_GATE !== "0";
+}
+var staticMatcherCache = new Map;
+async function staticProxyMatchers(file) {
+  let key;
+  try {
+    const stats = statSync(file);
+    key = `${stats.size}:${stats.mtimeMs}`;
+  } catch {
+    return;
+  }
+  const cached = staticMatcherCache.get(file);
+  if (cached?.key === key)
+    return cached.matchers;
+  let matchers;
+  try {
+    const { staticProxyConfig } = await import("./proxy-config-9r9e0jvn.js");
+    const config = staticProxyConfig(file, readFileSync(file, "utf8"));
+    if (config)
+      matchers = proxyMatchers(config);
+  } catch {
+    matchers = undefined;
+  }
+  staticMatcherCache.set(file, { key, matchers });
+  return matchers;
+}
+function proxyMatchers(config) {
+  const matcher = config?.matcher;
+  if (!matcher)
+    return [{ regex: /.*/ }];
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.map((item) => ({
+    regex: matcherRegex(matcherSource(item)),
+    ...typeof item === "object" && item.has ? { has: item.has } : {},
+    ...typeof item === "object" && item.missing ? { missing: item.missing } : {}
+  }));
+}
+function matchesProxy(matchers, url, request) {
+  const { pathname } = url;
+  const decoded = pathname.includes("%") ? decodedPathnames(pathname) : [];
+  return matchers.some((matcher) => (matcher.regex.test(pathname) || decoded.some((item) => matcher.regex.test(item))) && matchesConditions(matcher, url, request));
+}
+function matchesConditions(matcher, url, request) {
+  if (matcher.has && !matcher.has.every((condition) => hasCondition(condition, url, request))) {
+    return false;
+  }
+  if (matcher.missing?.some((condition) => hasCondition(condition, url, request))) {
+    return false;
+  }
+  return true;
+}
+function hasCondition(condition, url, request) {
+  const actual = conditionValue(condition, url, request);
+  if (actual === null)
+    return false;
+  if (condition.value === undefined)
+    return true;
+  try {
+    return new RegExp(`^${condition.value}$`).test(actual);
+  } catch {
+    return condition.value === actual;
+  }
+}
+function conditionValue(condition, url, request) {
+  switch (condition.type) {
+    case "header":
+      return condition.key ? request.headers.get(condition.key) : null;
+    case "query":
+      return condition.key ? url.searchParams.get(condition.key) : null;
+    case "cookie": {
+      if (!condition.key)
+        return null;
+      const cookie = parseCookies(request.headers.get("cookie") ?? "").find((item) => item.name === condition.key);
+      return cookie ? cookie.value : null;
+    }
+    case "host":
+      return url.host;
+    default:
+      return null;
+  }
+}
+function decodedPathnames(pathname) {
+  const decoded = [pathname.replace(/%2f/gi, "/")];
+  try {
+    decoded.push(decodeURIComponent(pathname));
+  } catch {}
+  return decoded;
+}
+function matcherSource(matcher) {
+  return typeof matcher === "string" ? matcher : matcher.source;
+}
+function matcherRegex(matcher) {
+  return new RegExp(anchoredMatcherPattern(matcher));
+}
+function anchoredMatcherPattern(matcher) {
+  return `^(?:${matcherPattern(matcher)})/*$`;
+}
+function matcherPattern(matcher) {
+  if (matcher.includes("("))
+    return matcher;
+  if (matcher === "/")
+    return "/";
+  let source = "";
+  for (const segment of matcher.split("/").filter(Boolean)) {
+    if (/^:[^/]+\*$/.test(segment)) {
+      source += "(?:/.*)?";
+    } else if (/^:[^/]+$/.test(segment)) {
+      source += "/[^/]+";
+    } else {
+      source += `/${escapeRegex(segment)}`;
+    }
+  }
+  return source || "/";
+}
+function rewriteRequest(request, url) {
+  return new Request(new URL(url, request.url), request);
+}
+function stripRscUnionQuery(request) {
+  const url = new URL(request.url);
+  if (!url.searchParams.has("_rsc"))
+    return request;
+  url.searchParams.delete("_rsc");
+  return new Request(url, request);
+}
+var FLIGHT_HEADERS = [
+  "rsc",
+  "next-router-state-tree",
+  "next-router-prefetch",
+  "next-hmr-refresh",
+  "next-router-segment-prefetch"
+];
+function stripFlightHeaders(request) {
+  if (!FLIGHT_HEADERS.some((header) => request.headers.has(header)))
+    return request;
+  const headers = new Headers(request.headers);
+  for (const header of FLIGHT_HEADERS)
+    headers.delete(header);
+  return new Request(request, { headers });
+}
+function applyRequestOverride(request, headers) {
+  if (!headers)
+    return request;
+  return new Request(request, { headers });
+}
+function applyProxyCookies(request, response) {
+  const setCookies = getSetCookie(response.headers);
+  if (setCookies.length === 0)
+    return request;
+  const cookies = parseCookies(request.headers.get("cookie") ?? "");
+  for (const header of setCookies) {
+    const cookie = parseSetCookie(header);
+    if (!cookie)
+      continue;
+    const index = cookies.findIndex((item) => item.name === cookie.name);
+    if (cookie.deleted) {
+      if (index !== -1)
+        cookies.splice(index, 1);
+      continue;
+    }
+    if (index === -1)
+      cookies.push({ name: cookie.name, value: cookie.value });
+    else
+      cookies[index] = { name: cookie.name, value: cookie.value };
+  }
+  const headers = new Headers(request.headers);
+  const cookieHeader = requestCookieHeader(cookies);
+  if (cookieHeader)
+    headers.set("cookie", cookieHeader);
+  else
+    headers.delete("cookie");
+  return new Request(request, { headers });
+}
+function parseSetCookie(header) {
+  const [pair = "", ...attributes] = header.split(";").map((part) => part.trim());
+  const [name = "", ...valueParts] = pair.split("=");
+  if (!name)
+    return;
+  const deleted = attributes.some((attribute) => /^max-age=0$/i.test(attribute));
+  return { name: decodeCookiePart(name), value: decodeCookiePart(valueParts.join("=")), deleted };
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function proxyModuleKey(options) {
+  return options.dev ? `dev:${options.devImportVersion ?? "dev"}` : "prod";
+}
+
+export { setProxyRewriteObserver, setProxyRunObserver, findProxyFile, proxyExternalLoadTarget, findProxyFiles, validateProxyFiles, createProxyRunner, applyProxyResponse, proxyRoutePatterns };

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

@@ -0,0 +1,152 @@
+// @bun
+import {
+  nextCompatEnabled
+} from "./index-web361b8.js";
+import {
+  cssModuleScopePath,
+  ensureDir,
+  readText
+} from "./index-4qsce64w.js";
+import {
+  productionRelease
+} from "./index-fpghsgb4.js";
+import {
+  getCssExtensions
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/utils/asset-hash.ts
+import { createHash } from "crypto";
+function assetContentHash(bytes) {
+  return createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+}
+function hashedAssetName(name, bytes) {
+  const hash = assetContentHash(bytes);
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 ? `${name}-${hash}` : `${name.slice(0, dot)}-${hash}${name.slice(dot)}`;
+}
+
+// src/css/assets.ts
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+var build;
+async function globalCssHref(config) {
+  const sources = productionRelease(config)?.globalCss ?? (await (build ??= import("./build-jda155c9.js"))).globalCssSources(config);
+  return sources.length > 0 ? assetHref(config, "global.css") : undefined;
+}
+var emittedAssets = new Map;
+function recordEmittedAsset(outPath, logical, emitted) {
+  const names = emittedAssets.get(outPath) ?? new Map;
+  names.set(logical, emitted);
+  emittedAssets.set(outPath, names);
+}
+function publishEmittedAssets(outPath, names) {
+  if (!names)
+    return;
+  for (const [logical, emitted] of Object.entries(names))
+    recordEmittedAsset(outPath, logical, emitted);
+}
+function emittedAssetNames(outPath) {
+  return Object.fromEntries(emittedAssets.get(outPath) ?? []);
+}
+function clearEmittedAssets(outPath) {
+  emittedAssets.delete(outPath);
+}
+function emittedAssetName(config, name) {
+  if (!config?.outPath)
+    return name;
+  return emittedAssets.get(config.outPath)?.get(name) ?? name;
+}
+function assetPathname(config, name) {
+  const emitted = emittedAssetName(config, name);
+  return nextCompatEnabled(config ?? {}) ? `/_next/static/${emitted}` : `/assets/${emitted}`;
+}
+function assetHref(config, name) {
+  return withAssetPrefix(config, assetPathname(config, name));
+}
+function routeCssAssetNames(route) {
+  if (route.cssImports.length === 0)
+    return [];
+  return route.cssAssets?.length ? route.cssAssets : [`${route.id}.css`];
+}
+function routeCssHref(route, config) {
+  const assets = routeCssAssetNames(route);
+  if (assets.length === 0)
+    return;
+  return assets.map((asset) => assetHref(config, asset));
+}
+async function emitFontCssStylesheet(config, routeId, fontCss, baseAsset, options) {
+  const outDir = path.join(config.outPath, options.dev ? "cache" : "static", "assets");
+  await ensureDir(outDir);
+  const baseFile = baseAsset ? path.join(outDir, baseAsset) : undefined;
+  const baseCss = baseFile && existsSync(baseFile) ? await readFile(baseFile, "utf8") : "";
+  const contents = [fontCss, baseCss].filter(Boolean).join(`
+`);
+  const logicalName = baseAsset ? baseAsset.replace(/-[0-9a-f]{16}(?=\.css$)/, "") : `${routeId}.css`;
+  const name = hashedAssetName(logicalName, contents);
+  const file = path.join(outDir, name);
+  if (!existsSync(file) || await readFile(file, "utf8") !== contents)
+    await writeFile(file, contents);
+  return name;
+}
+function withAssetPrefix(config, href) {
+  const prefix = config?.assetPrefix;
+  if (!prefix)
+    return href;
+  return `${prefix.replace(/\/$/, "")}${href}`;
+}
+var cssRuntimeRegistered = false;
+function registerCssRuntime() {
+  if (cssRuntimeRegistered)
+    return;
+  cssRuntimeRegistered = true;
+  Bun.plugin({
+    name: "pnext-css-runtime",
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.(?:css|scss|sass)$/ }, async ({ path: file }) => isCssModuleFile(file) ? {
+        exports: { default: await cssModuleMapping(file) },
+        loader: "object"
+      } : {
+        contents: "export default undefined;",
+        loader: "js"
+      });
+    }
+  });
+}
+function isCssModuleFile(file) {
+  return /\.module\.(?:css|scss|sass)$/.test(file);
+}
+async function cssModuleMapping(file) {
+  const compatMapping = getCssExtensions().resolveCssModule(file);
+  if (compatMapping)
+    return compatMapping;
+  const source = await readText(file);
+  const classNames = cssClassNames(source);
+  return Object.fromEntries([...classNames].map((className) => [className, cssModuleClassName(file, className)]));
+}
+function cssClassNames(source) {
+  const classNames = new Set;
+  const classPattern = /(^|[^\\])\.(-?[_a-zA-Z][\w-]*)/g;
+  let match;
+  while (match = classPattern.exec(source)) {
+    if (match[2])
+      classNames.add(match[2]);
+  }
+  return classNames;
+}
+function cssModuleClassName(file, className) {
+  const base = path.basename(file).replace(/\.module\.css$/, "").replace(/[^_a-zA-Z0-9]/g, "_");
+  const hash = pathHash(cssModuleScopePath(file));
+  return `${base}_${className}_${hash}`;
+}
+function pathHash(file) {
+  let hash = 5381;
+  for (const char of file)
+    hash = (hash << 5) + hash ^ char.charCodeAt(0);
+  return (hash >>> 0).toString(36).slice(0, 5);
+}
+
+export { assetContentHash, hashedAssetName, globalCssHref, recordEmittedAsset, publishEmittedAssets, emittedAssetNames, clearEmittedAssets, emittedAssetName, assetPathname, assetHref, routeCssAssetNames, routeCssHref, emitFontCssStylesheet, withAssetPrefix, registerCssRuntime, isCssModuleFile, cssModuleMapping, cssClassNames, cssModuleClassName };