@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-O4F3JUST.mjs

@@ -0,0 +1,176 @@
+// src/client/chunk-recovery.ts
+var DEFAULT_MAX_AGE_MS = 3e4;
+var STORAGE_KEY_PREFIX = "farm:chunk-recovery:";
+var CHUNK_ERROR_PATTERNS = [
+  /ChunkLoadError/i,
+  /Loading chunk [\w-]+ failed/i,
+  /Loading CSS chunk [\w-]+ failed/i,
+  /CSS_CHUNK_LOAD_FAILED/i,
+  /failed to fetch dynamically imported module/i,
+  /error loading dynamically imported module/i,
+  /importing a module script failed/i,
+  /unable to preload CSS/i,
+  /module script failed/i
+];
+function isChunkLoadError(errorLike) {
+  const values = collectErrorText(errorLike);
+  if (values.some((value) => CHUNK_ERROR_PATTERNS.some((pattern) => pattern.test(value)))) {
+    return true;
+  }
+  const targetUrl = getEventTargetAssetUrl(errorLike);
+  return Boolean(
+    targetUrl && /\.(?:m?js|css)(?:[?#].*)?$/i.test(targetUrl) && isSameOriginAssetUrl(targetUrl)
+  );
+}
+function isSameOriginAssetUrl(url) {
+  if (typeof window === "undefined" || !window.location) {
+    return false;
+  }
+  try {
+    return new URL(url, window.location.href).origin === window.location.origin;
+  } catch {
+    return false;
+  }
+}
+function installChunkErrorRecovery(options = {}) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const recover = (errorLike) => {
+    if (!isChunkLoadError(errorLike)) {
+      return;
+    }
+    if (!markRecovered(options)) {
+      return;
+    }
+    options.onRecover?.(errorLike);
+    getReload(options)();
+  };
+  const onError = (event) => {
+    recover(getErrorEventPayload(event));
+  };
+  const onUnhandledRejection = (event) => {
+    recover(event.reason);
+  };
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+function markRecovered(options) {
+  const now = getNow(options);
+  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const storage = getStorage(options);
+  const key = getStorageKey(options);
+  if (!storage) {
+    return false;
+  }
+  try {
+    const previous = Number(storage.getItem(key));
+    if (Number.isFinite(previous) && previous > 0 && now - previous < maxAgeMs) {
+      return false;
+    }
+    storage.setItem(key, String(now));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getErrorEventPayload(event) {
+  if ("error" in event && event.error) {
+    return event.error;
+  }
+  if ("message" in event && event.message) {
+    return event.message;
+  }
+  return event;
+}
+function collectErrorText(value, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || seen.has(value)) {
+    return [];
+  }
+  seen.add(value);
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+  const record = value;
+  const output = [];
+  for (const key of ["name", "message", "code", "type", "request", "src", "href"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string") {
+      output.push(candidate);
+    }
+  }
+  if ("reason" in record) {
+    output.push(...collectErrorText(record.reason, seen));
+  }
+  if ("error" in record) {
+    output.push(...collectErrorText(record.error, seen));
+  }
+  return output;
+}
+function getEventTargetAssetUrl(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const target = value.target;
+  if (!target || typeof target !== "object") {
+    return void 0;
+  }
+  const tagName = typeof target.tagName === "string" ? target.tagName.toLowerCase() : "";
+  if (tagName === "script") {
+    if (target.type !== "module" && target.noModule !== true) return void 0;
+  } else if (tagName === "link") {
+    const rel = typeof target.rel === "string" ? target.rel.toLowerCase().split(/\s+/) : [];
+    if (!rel.some((value2) => ["stylesheet", "modulepreload", "preload"].includes(value2))) {
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+  return typeof target.src === "string" && target.src ? target.src : typeof target.href === "string" && target.href ? target.href : void 0;
+}
+function getStorage(options) {
+  if ("storage" in options) {
+    return options.storage;
+  }
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function getStorageKey(options) {
+  if (options.storageKey) {
+    return options.storageKey;
+  }
+  const location = getLocation(options);
+  return `${STORAGE_KEY_PREFIX}${location.pathname}${location.search}`;
+}
+function getLocation(options) {
+  return options.location ?? window.location;
+}
+function getReload(options) {
+  if (options.reload) {
+    return options.reload;
+  }
+  const location = getLocation(options);
+  return () => location.reload();
+}
+function getNow(options) {
+  return options.now ? options.now() : Date.now();
+}
+
+export {
+  isChunkLoadError,
+  installChunkErrorRecovery
+};

package/dist/chunk-OAJOQU5J.mjs

@@ -0,0 +1,225 @@
+import {
+  appendFarmRedirectQuery
+} from "./chunk-XQ4DPO4G.mjs";
+import {
+  compileConfigRoutePattern,
+  interpolateConfigRouteDestination,
+  localizeConfigRouteDestination,
+  resolveConfigRoutePathname
+} from "./chunk-ONG4RDW3.mjs";
+import {
+  isFarmRedirectStatus
+} from "./chunk-JNYFXL7X.mjs";
+import {
+  resolveFarmRequestURL
+} from "./chunk-6HRAK7I5.mjs";
+
+// src/plugins/redirects.ts
+function createRedirectsPlugin(redirects, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  for (const redirect of redirects) {
+    if (redirect.statusCode !== void 0 && !isFarmRedirectStatus(redirect.statusCode)) {
+      throw new RangeError(
+        `Redirect "${redirect.source}" statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+  }
+  const compiledRedirects = redirects.map((redirect) => ({
+    redirect,
+    pattern: compileConfigRoutePattern(redirect.source)
+  }));
+  return {
+    name: "farm:redirects",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = resolveFarmRequestURL(req);
+      const routePath = resolveConfigRoutePathname(url.pathname, i18n);
+      const pathname = routePath.pathname;
+      for (const { redirect, pattern } of compiledRedirects) {
+        const match = pathname.match(pattern.regex);
+        if (match) {
+          const localizedDestination = localizeConfigRouteDestination(
+            interpolateConfigRouteDestination(redirect.destination, match, pattern.tokens),
+            routePath.locale,
+            i18n
+          );
+          const destination = appendFarmRedirectQuery(localizedDestination, url.search);
+          const statusCode = redirect.statusCode ?? (redirect.permanent ? 308 : 307);
+          res.writeHead(statusCode, {
+            Location: destination
+          });
+          res.end();
+          return;
+        }
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/headers.ts
+var FARM_CONFIG_HEADERS_FINALIZER = /* @__PURE__ */ Symbol.for("farm.configHeadersFinalizer");
+function appendConfiguredLinkHeader(res, value) {
+  const current = res.getHeader("Link");
+  if (current === void 0) {
+    res.setHeader("Link", value);
+    return;
+  }
+  const currentValue = Array.isArray(current) ? current.join(", ") : String(current);
+  if (currentValue !== value && !currentValue.endsWith(`, ${value}`)) {
+    res.setHeader("Link", `${currentValue}, ${value}`);
+  }
+}
+function appendConfiguredSetCookieHeader(res, value) {
+  const current = res.getHeader("Set-Cookie");
+  if (current === void 0) {
+    res.setHeader("Set-Cookie", value);
+    return;
+  }
+  const values = (Array.isArray(current) ? current : [current]).map(String);
+  if (!values.includes(value)) {
+    res.setHeader("Set-Cookie", [...values, value]);
+  }
+}
+function applyResponseHeaders(res, matchedHeaders) {
+  for (const headers of matchedHeaders) {
+    for (const header of headers) {
+      const key = header.key.toLowerCase();
+      if (key === "link") {
+        appendConfiguredLinkHeader(res, header.value);
+      } else if (key === "set-cookie") {
+        appendConfiguredSetCookieHeader(res, header.value);
+      } else {
+        res.setHeader(header.key, header.value);
+      }
+    }
+  }
+}
+function applyWriteHeadHeaders(res, headers) {
+  if (Array.isArray(headers)) {
+    let setCookieWritten = false;
+    for (let index = 0; index + 1 < headers.length; index += 2) {
+      const key = String(headers[index]);
+      const value = headers[index + 1];
+      if (key.toLowerCase() === "set-cookie" && setCookieWritten) {
+        const current = res.getHeader("Set-Cookie");
+        const values = (Array.isArray(current) ? current : [current]).filter(
+          (entry) => entry !== void 0
+        );
+        res.setHeader("Set-Cookie", [...values, ...Array.isArray(value) ? value : [value]]);
+      } else {
+        res.setHeader(key, value);
+        if (key.toLowerCase() === "set-cookie") setCookieWritten = true;
+      }
+    }
+    return;
+  }
+  if (!headers || typeof headers !== "object") return;
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== void 0) res.setHeader(key, value);
+  }
+}
+function createHeadersPlugin(headers, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  const compiledHeaders = headers.map((config) => ({
+    config,
+    pattern: compileConfigRoutePattern(config.source)
+  }));
+  return {
+    name: "farm:headers",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = resolveFarmRequestURL(req);
+      const pathname = resolveConfigRoutePathname(url.pathname, i18n).pathname;
+      const matchedHeaders = compiledHeaders.filter(({ pattern }) => pattern.regex.test(pathname)).map(({ config }) => config.headers);
+      applyResponseHeaders(res, matchedHeaders);
+      const responseWithFinalizer = res;
+      if (matchedHeaders.length === 0 || responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER]) {
+        return;
+      }
+      responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER] = true;
+      const writeHead = res.writeHead;
+      res.writeHead = ((statusCode, ...args) => {
+        const statusMessage = typeof args[0] === "string" ? args.shift() : void 0;
+        applyWriteHeadHeaders(res, args[0]);
+        applyResponseHeaders(res, matchedHeaders);
+        return statusMessage === void 0 ? writeHead.call(res, statusCode) : writeHead.call(res, statusCode, statusMessage);
+      });
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/env.ts
+function createEnvPlugin(env, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:env",
+    configResolved(config, context) {
+      for (const [key, value] of Object.entries(env)) {
+        process.env[key] = value;
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/logger.ts
+function createLoggerPlugin({
+  beforeRequest,
+  afterResponse
+} = {}) {
+  const plugin = {
+    name: "farm:logger",
+    enforce: "post"
+  };
+  if (beforeRequest) {
+    plugin.beforeRequest = async (req, res, context) => {
+      await beforeRequest(req, res, context);
+    };
+  }
+  if (afterResponse) {
+    plugin.afterResponse = async (req, res, context) => {
+      await afterResponse(req, res, context);
+    };
+  }
+  return plugin;
+}
+
+export {
+  createRedirectsPlugin,
+  createHeadersPlugin,
+  createEnvPlugin,
+  createLoggerPlugin
+};

package/dist/chunk-OCS3PSYR.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/instrumentation-runtime.ts
+function createFarmInstrumentationLifecycle(module, context) {
+  let startPromise;
+  let shutdownPromise;
+  let cleanup;
+  return {
+    start() {
+      if (!startPromise) {
+        startPromise = Promise.resolve(_optionalChain([module, 'optionalAccess', _ => _.register, 'optionalCall', _2 => _2(context)])).then((result) => {
+          cleanup = result || void 0;
+        });
+      }
+      return startPromise;
+    },
+    shutdown() {
+      if (!shutdownPromise) {
+        shutdownPromise = (async () => {
+          try {
+            await startPromise;
+          } catch (e) {
+          }
+          try {
+            if (typeof cleanup === "function") {
+              await cleanup();
+            } else if (_optionalChain([cleanup, 'optionalAccess', _3 => _3.shutdown])) {
+              await cleanup.shutdown();
+            }
+          } finally {
+            if (_optionalChain([module, 'optionalAccess', _4 => _4.shutdown])) {
+              await module.shutdown();
+            }
+          }
+        })();
+      }
+      return shutdownPromise;
+    }
+  };
+}
+function resolveFarmInstrumentationRuntime(preset) {
+  const normalized = _nullishCoalesce(_optionalChain([preset, 'optionalAccess', _5 => _5.toLowerCase, 'call', _6 => _6()]), () => ( ""));
+  if (normalized.includes("cloudflare") || normalized.includes("worker") || normalized.includes("edge")) {
+    return "edge";
+  }
+  if (normalized.includes("bun")) return "bun";
+  return "nodejs";
+}
+
+
+
+
+exports.createFarmInstrumentationLifecycle = createFarmInstrumentationLifecycle; exports.resolveFarmInstrumentationRuntime = resolveFarmInstrumentationRuntime;

package/dist/chunk-OHWM2VI4.mjs

@@ -0,0 +1,29 @@
+// src/utils/decode.ts
+function decodeRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function canonicalizeRequestPathSegments(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (!pathname.includes("%")) return segments;
+  return segments.map(decodeRouteSegment);
+}
+function canonicalizeRequestPathname(pathname) {
+  const encoded = pathname.includes("%");
+  if (!encoded && !pathname.includes("//")) return pathname;
+  const collapsed = pathname.replace(/\/{2,}/g, "/");
+  if (!encoded) return collapsed;
+  return collapsed.split("/").map((segment) => {
+    const decoded = decodeRouteSegment(segment);
+    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
+  }).join("/");
+}
+
+export {
+  decodeRouteSegment,
+  canonicalizeRequestPathSegments,
+  canonicalizeRequestPathname
+};

package/dist/chunk-OJO2GOM3.mjs

@@ -0,0 +1,69 @@
+// src/api/dev-dispatch.ts
+import http from "http";
+import https from "https";
+import { Readable } from "stream";
+function createFarmDevServerDispatch(server) {
+  return (request) => new Promise((resolve, reject) => {
+    const address = server.httpServer?.address();
+    if (!address || typeof address === "string") {
+      throw new Error(
+        "Farm cannot dispatch an app endpoint request: the Vite dev server has no listening HTTP server."
+      );
+    }
+    const url = new URL(request.url);
+    const headers = {};
+    request.headers.forEach((value, name) => {
+      headers[name] = value;
+    });
+    headers.host = url.host;
+    const secure = Boolean(server.config.server.https);
+    const outgoing = (secure ? https : http).request(
+      {
+        host: loopbackAddress(address),
+        port: address.port,
+        method: request.method,
+        path: `${url.pathname}${url.search}`,
+        headers,
+        signal: request.signal,
+        // The listener is this process's own dev server, often with a self-signed certificate.
+        ...secure ? { rejectUnauthorized: false } : {}
+      },
+      (incoming) => {
+        const responseHeaders = new Headers();
+        for (const [name, value] of Object.entries(incoming.headers)) {
+          if (value === void 0) continue;
+          for (const entry of Array.isArray(value) ? value : [value]) {
+            responseHeaders.append(name, entry);
+          }
+        }
+        const status = incoming.statusCode ?? 502;
+        const hasBody = request.method !== "HEAD" && status !== 204 && status !== 205 && status !== 304;
+        if (!hasBody) incoming.resume();
+        try {
+          resolve(
+            new Response(
+              hasBody ? Readable.toWeb(incoming) : null,
+              { status, statusText: incoming.statusMessage, headers: responseHeaders }
+            )
+          );
+        } catch (error) {
+          incoming.destroy();
+          reject(error);
+        }
+      }
+    );
+    outgoing.on("error", reject);
+    if (request.body) {
+      Readable.fromWeb(request.body).on("error", (error) => outgoing.destroy(error)).pipe(outgoing);
+    } else {
+      outgoing.end();
+    }
+  });
+}
+function loopbackAddress({ address }) {
+  return address === "0.0.0.0" ? "127.0.0.1" : address === "::" ? "::1" : address;
+}
+
+export {
+  createFarmDevServerDispatch
+};