@wular/coder 0.4.2 → 0.4.5

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

@@ -0,0 +1,182 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  currentRequest,
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/lifecycle/testmode.ts
+import { PassThrough } from "stream";
+import { createRequire } from "module";
+var requireNode = createRequire(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/compat/lifecycle/testmode.ts").href);
+var TEST_PROXY_KEY = Symbol.for("pnext.testProxy");
+function readTestProxyInfo(headers) {
+  const portHeader = headers.get("next-test-proxy-port");
+  if (!portHeader)
+    return;
+  return { proxyPort: Number(portHeader), testData: headers.get("next-test-data") ?? "" };
+}
+function activateTestProxy(headers) {
+  const info = readTestProxyInfo(headers);
+  if (!info)
+    return;
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  (unit.compat ??= {})[TEST_PROXY_KEY] = info;
+}
+function currentTestProxyInfo() {
+  const workUnitInfo = getWorkUnit()?.compat?.[TEST_PROXY_KEY];
+  if (workUnitInfo)
+    return workUnitInfo;
+  const request = currentRequest();
+  if (!request)
+    return;
+  return readTestProxyInfo(request.headers);
+}
+async function buildProxyRequest(testData, request) {
+  return {
+    testData,
+    api: "fetch",
+    request: {
+      url: request.url,
+      method: request.method,
+      headers: [...Array.from(request.headers), ["next-test-stack", getTestStack()]],
+      body: request.body ? Buffer.from(await request.arrayBuffer()).toString("base64") : null,
+      cache: request.cache,
+      credentials: request.credentials,
+      integrity: request.integrity,
+      mode: request.mode === "navigate" ? "cors" : request.mode,
+      redirect: request.redirect,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy
+    }
+  };
+}
+function getTestStack() {
+  let stack = (new Error().stack ?? "").split(`
+`);
+  for (let i = 1;i < stack.length; i++) {
+    const line = stack[i];
+    if (line && line.length > 0) {
+      stack = stack.slice(i);
+      break;
+    }
+  }
+  stack = stack.filter((item) => !item.includes("/next/dist/"));
+  stack = stack.slice(0, 5);
+  stack = stack.map((line) => line.replace("webpack-internal:///(rsc)/", "").trim());
+  return stack.join("    ");
+}
+async function handleProxiedFetch(originalFetch, info, request) {
+  const proxyRequest = await buildProxyRequest(info.testData, request);
+  const resp = await originalFetch(`http://localhost:${info.proxyPort}`, {
+    method: "POST",
+    body: JSON.stringify(proxyRequest),
+    next: { internal: true }
+  });
+  if (!resp.ok)
+    throw new Error(`Proxy request failed: ${resp.status}`);
+  const proxyResponse = await resp.json();
+  switch (proxyResponse.api) {
+    case "continue":
+      return originalFetch(request);
+    case "fetch": {
+      const r = proxyResponse.response;
+      return new Response(r.body ? Buffer.from(r.body, "base64") : null, {
+        status: r.status,
+        headers: new Headers(r.headers)
+      });
+    }
+    default:
+      throw new Error(`Proxy request aborted [${request.method} ${request.url}]`);
+  }
+}
+function buildResponseMessage(responsePromise, callback) {
+  const stream = new PassThrough;
+  const message = stream;
+  responsePromise.then(async (response) => {
+    const headers = {};
+    const rawHeaders = [];
+    for (const [name, value] of response.headers) {
+      headers[name.toLowerCase()] = value;
+      rawHeaders.push(name, value);
+    }
+    message.statusCode = response.status;
+    message.statusMessage = response.statusText;
+    message.headers = headers;
+    message.rawHeaders = rawHeaders;
+    message.complete = true;
+    callback?.(message);
+    const body = await response.arrayBuffer();
+    stream.end(Buffer.from(body));
+  }).catch((error) => {
+    stream.emit("error", error);
+    stream.end();
+  });
+  return message;
+}
+function getStringForGetInput(input) {
+  if (typeof input === "string" || input instanceof URL)
+    return input.toString();
+  const candidate = input;
+  if (typeof candidate.href === "string" && /^[a-z][a-z\d+.-]*:\/\//i.test(candidate.href))
+    return candidate.href;
+  const protocol = typeof candidate.protocol === "string" ? candidate.protocol : "http:";
+  const host = typeof candidate.host === "string" ? candidate.host : typeof candidate.hostname === "string" ? candidate.hostname : undefined;
+  if (!host)
+    return;
+  const port = typeof candidate.port === "number" ? `:${candidate.port}` : typeof candidate.port === "string" ? `:${candidate.port}` : "";
+  const path = typeof candidate.path === "string" ? candidate.path : typeof candidate.pathname === "string" ? candidate.pathname : "/";
+  const search = typeof candidate.search === "string" ? candidate.search : "";
+  return `${protocol}//${host}${port}${path}${search}`;
+}
+function patchableGet(originalGet, originalFetch) {
+  return (input, options) => {
+    const callback = typeof options === "function" ? options : undefined;
+    const url = getStringForGetInput(input);
+    const info = currentTestProxyInfo();
+    if (!url || !info) {
+      if (typeof options === "function") {
+        return originalGet(input, options);
+      }
+      if (options === undefined) {
+        return originalGet(input);
+      }
+      return originalGet(input, options);
+    }
+    const request = new Request(url, {
+      method: typeof options === "object" && options && "method" in options && typeof options.method === "string" ? options.method : "GET",
+      headers: typeof options === "object" && options && "headers" in options ? options.headers : undefined
+    });
+    return buildResponseMessage(handleProxiedFetch(originalFetch, info, request), callback);
+  };
+}
+var patched = false;
+function installTestProxyFetch() {
+  if (patched)
+    return;
+  patched = true;
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  const testFetch = function testFetch2(input, init) {
+    const nextInit = init?.next;
+    if (nextInit?.internal) {
+      return originalFetch(input, init);
+    }
+    const info = currentTestProxyInfo();
+    if (!info)
+      return originalFetch(input, init);
+    return handleProxiedFetch(originalFetch, info, new Request(input, init));
+  };
+  testFetch.preconnect = originalFetch.preconnect?.bind(originalFetch);
+  globalThis.fetch = testFetch;
+  const httpModule = requireNode("node:http");
+  const httpsModule = requireNode("node:https");
+  const originalHttpGet = httpModule.get;
+  const originalHttpsGet = httpsModule.get;
+  httpModule.get = patchableGet(originalHttpGet, originalFetch);
+  httpsModule.get = patchableGet(originalHttpsGet, originalFetch);
+}
+
+export { activateTestProxy, installTestProxyFetch };

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

@@ -0,0 +1,128 @@
+// @bun
+import {
+  findProxyFile
+} from "./index-3ycf5ckv.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/routing/proxy-config.ts
+import { readFileSync } from "fs";
+import path from "path";
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+function releasedProxy(config) {
+  const file = findProxyFile(config);
+  if (!file)
+    return;
+  try {
+    return { file, config: staticProxyConfig(file, readFileSync(file, "utf8")) };
+  } catch {
+    return { file };
+  }
+}
+function staticProxyConfig(file, source) {
+  const result = parseSync(file, source, { lang: parserLang(file) });
+  if (result.errors.length > 0)
+    return;
+  for (const statement of result.program.body) {
+    if (statement.type !== "ExportNamedDeclaration")
+      continue;
+    const declaration = statement.declaration;
+    if (declaration?.type !== "VariableDeclaration")
+      continue;
+    for (const declarator of declaration.declarations ?? []) {
+      if (declarator.id?.type !== "Identifier" || declarator.id.name !== "config")
+        continue;
+      const value = staticValue(declarator.init);
+      return isProxyConfigShape(value) ? value : undefined;
+    }
+  }
+  return;
+}
+function parserLang(file) {
+  const ext = path.extname(file);
+  if (ext === ".tsx")
+    return "tsx";
+  if (ext === ".jsx")
+    return "jsx";
+  return ext === ".js" || ext === ".mjs" ? "js" : "ts";
+}
+function staticValue(node) {
+  if (!node)
+    return;
+  switch (node.type) {
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+      return staticValue(node.expression);
+    case "Literal":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return node.value === null ? undefined : node.value;
+    case "TemplateLiteral":
+      return node.expressions?.length === 0 ? node.quasis?.[0]?.value?.cooked ?? undefined : undefined;
+    case "ArrayExpression": {
+      const items = [];
+      for (const element of node.elements ?? []) {
+        const value = staticValue(element);
+        if (value === undefined)
+          return;
+        items.push(value);
+      }
+      return items;
+    }
+    case "ObjectExpression": {
+      const object = {};
+      for (const property of node.properties ?? []) {
+        if (property.type !== "Property" && property.type !== "ObjectProperty")
+          return;
+        if (property.computed)
+          return;
+        const key = property.key?.type === "Identifier" ? property.key.name : property.key?.value;
+        if (typeof key !== "string")
+          return;
+        const value = staticValue(property.value);
+        if (value === undefined)
+          return;
+        object[key] = value;
+      }
+      return object;
+    }
+    default:
+      return;
+  }
+}
+function isProxyConfigShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const matcher = value.matcher;
+  if (matcher === undefined)
+    return true;
+  const items = Array.isArray(matcher) ? matcher : [matcher];
+  return items.every((item) => {
+    if (typeof item === "string")
+      return true;
+    if (typeof item !== "object" || item === null)
+      return false;
+    const { source, has, missing } = item;
+    if (typeof source !== "string")
+      return false;
+    return [has, missing].every((list) => list === undefined || Array.isArray(list) && list.every(isConditionShape));
+  });
+}
+function isConditionShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const { type, key, value: expected } = value;
+  if (type !== "header" && type !== "query" && type !== "cookie" && type !== "host")
+    return false;
+  if (key !== undefined && typeof key !== "string")
+    return false;
+  return expected === undefined || typeof expected === "string";
+}
+
+export { releasedProxy, staticProxyConfig };