@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-XGC343EY.cjs

@@ -0,0 +1,443 @@
+"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; }
+
+var _chunkRG3ZOTG5cjs = require('./chunk-RG3ZOTG5.cjs');
+
+
+var _chunk5ZSWG4UXcjs = require('./chunk-5ZSWG4UX.cjs');
+
+
+var _chunkUS2QVW3Ecjs = require('./chunk-US2QVW3E.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/middleware/server.ts
+var _async_hooks = require('async_hooks');
+var MIDDLEWARE_DATA_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareDataStore");
+var MIDDLEWARE_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareContextStore");
+function getGlobalMiddlewareStore(key) {
+  const state = globalThis;
+  const existing = state[key];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const store = new (0, _async_hooks.AsyncLocalStorage)();
+  state[key] = store;
+  return store;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getGlobalMiddlewareStore, "getGlobalMiddlewareStore");
+var middlewareStore = getGlobalMiddlewareStore(MIDDLEWARE_DATA_STORE_KEY);
+var middlewareContextStore = getGlobalMiddlewareStore(MIDDLEWARE_CONTEXT_STORE_KEY);
+function toMiddlewareMap(data) {
+  if (data instanceof Map) {
+    return new Map(data);
+  }
+  return new Map(Object.entries(data));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toMiddlewareMap, "toMiddlewareMap");
+function _clearCurrentMiddlewareData() {
+  middlewareStore.enterWith(/* @__PURE__ */ new Map());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareData, "_clearCurrentMiddlewareData");
+function _clearCurrentMiddlewareContext() {
+  middlewareContextStore.enterWith(/* @__PURE__ */ new Map());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareContext, "_clearCurrentMiddlewareContext");
+async function _runWithMiddlewareData(data, fn) {
+  return middlewareStore.run(toMiddlewareMap(data), fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareData, "_runWithMiddlewareData");
+async function _runWithMiddlewareContext(context, fn) {
+  return middlewareContextStore.run(toMiddlewareMap(context), fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareContext, "_runWithMiddlewareContext");
+function getMiddlewareData() {
+  return middlewareStore.getStore() || /* @__PURE__ */ new Map();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareData, "getMiddlewareData");
+function getMiddlewareValue(key) {
+  const data = getMiddlewareData();
+  return data.get(key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareValue, "getMiddlewareValue");
+function getMiddlewareContext() {
+  return middlewareContextStore.getStore() || /* @__PURE__ */ new Map();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareContext, "getMiddlewareContext");
+
+// src/middleware/cookie-header.ts
+function parseMiddlewareCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  for (const cookie of _chunkRG3ZOTG5cjs.parseRequestCookieHeader.call(void 0, cookieHeader)) {
+    if (!Object.prototype.hasOwnProperty.call(cookies, cookie.name)) {
+      cookies[cookie.name] = cookie.value;
+    }
+  }
+  return cookies;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseMiddlewareCookieHeader, "parseMiddlewareCookieHeader");
+function applyCookieNamePrefixRequirements(name, options) {
+  if (name.startsWith("__Host-")) {
+    return { ...options, secure: true, path: "/", domain: void 0 };
+  }
+  if (name.startsWith("__Secure-")) {
+    return { ...options, secure: true };
+  }
+  return options;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyCookieNamePrefixRequirements, "applyCookieNamePrefixRequirements");
+function serializeMiddlewareCookie(name, value, options = {}) {
+  const resolved = applyCookieNamePrefixRequirements(name, options);
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (resolved.maxAge != null) cookie += `; Max-Age=${resolved.maxAge}`;
+  if (resolved.expires) cookie += `; Expires=${resolved.expires.toUTCString()}`;
+  cookie += `; Path=${resolved.path || "/"}`;
+  if (resolved.domain) cookie += `; Domain=${resolved.domain}`;
+  if (resolved.secure) cookie += "; Secure";
+  if (resolved.httpOnly) cookie += "; HttpOnly";
+  if (resolved.sameSite) {
+    cookie += `; SameSite=${resolved.sameSite.charAt(0).toUpperCase()}${resolved.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeMiddlewareCookie, "serializeMiddlewareCookie");
+function serializeMiddlewareCookieDeletion(name, options = {}) {
+  return serializeMiddlewareCookie(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeMiddlewareCookieDeletion, "serializeMiddlewareCookieDeletion");
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isWebRequest, "isWebRequest");
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return _chunk5ZSWG4UXcjs.createWebRequestFromFarmRequest.call(void 0, ctx.request, { origin: ctx.url.origin });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toWebRequest, "toWebRequest");
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRequestMiddlewareContext, "createRequestMiddlewareContext");
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module = middlewareModule;
+  const defaultExport = module.default;
+  const namedExport = module.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(_optionalChain([built, 'optionalAccess', _ => _.handlers])) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module.config || _optionalChain([built, 'optionalAccess', _2 => _2.config])
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module.config
+    };
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeMiddlewareModule, "normalizeMiddlewareModule");
+
+// src/middleware/matcher.ts
+var compiledConfigCache = /* @__PURE__ */ new WeakMap();
+var compiledRouteCache = /* @__PURE__ */ new WeakMap();
+function compileMiddlewareRoute(entry) {
+  const path = entry.path;
+  if (path === "/") return void 0;
+  const cached = compiledRouteCache.get(entry);
+  if (_optionalChain([cached, 'optionalAccess', _3 => _3.path]) === path) return cached;
+  const compiled = {
+    path,
+    exact: compilePattern(path),
+    nested: compilePattern(`${path}/:__farmRest*`)
+  };
+  compiledRouteCache.set(entry, compiled);
+  return compiled;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compileMiddlewareRoute, "compileMiddlewareRoute");
+function matchesMiddlewareRoute(pathname, entry) {
+  const compiled = compileMiddlewareRoute(entry);
+  if (!compiled) return { matched: true };
+  const canonicalPathname = _chunkUS2QVW3Ecjs.canonicalizeRequestPathname.call(void 0, pathname);
+  const exactMatch = matchPattern(compiled.exact, canonicalPathname);
+  if (exactMatch.matched) return exactMatch;
+  const nestedMatch = matchPattern(compiled.nested, canonicalPathname);
+  if (!nestedMatch.matched) return { matched: false };
+  const params = { ...nestedMatch.params };
+  delete params.__farmRest;
+  return { matched: true, params: Object.keys(params).length > 0 ? params : void 0 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesMiddlewareRoute, "matchesMiddlewareRoute");
+function sameEntries(current, previous) {
+  return current === void 0 || previous === void 0 ? current === previous : current.length === previous.length && current.every((entry, index) => entry === previous[index]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sameEntries, "sameEntries");
+function toMatcherList(matcher) {
+  if (!matcher) return [];
+  return Array.isArray(matcher) ? matcher : [matcher];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toMatcherList, "toMatcherList");
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeRegex, "escapeRegex");
+function parseColonParam(segment) {
+  const raw = segment.slice(1);
+  const last = raw[raw.length - 1];
+  const modifier = last === "*" || last === "+" || last === "?" ? last : void 0;
+  return {
+    name: modifier ? raw.slice(0, -1) : raw,
+    modifier
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseColonParam, "parseColonParam");
+function compilePathPattern(pattern, trailingSlash = false) {
+  const params = [];
+  const segments = pattern.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return { kind: "path", regex: /^\/$/, params };
+  }
+  const parts = segments.map((segment) => {
+    if (segment === "**") {
+      return "(?:/.*)?";
+    }
+    if (segment === "*") {
+      return "/[^/]+";
+    }
+    if (segment.startsWith(":")) {
+      const { name, modifier } = parseColonParam(segment);
+      params.push(name);
+      if (modifier === "*") {
+        return "(?:/(.*))?";
+      }
+      if (modifier === "+") {
+        return "/(.+)";
+      }
+      return "/([^/]+)";
+    }
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      params.push(segment.slice(4, -1));
+      return "(?:/(.*))?";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      params.push(segment.slice(1, -1));
+      return "/([^/]+)";
+    }
+    return `/${escapeRegex(segment).replace(/\\\*/g, "[^/]*")}`;
+  });
+  return {
+    kind: "path",
+    regex: new RegExp(`^${parts.join("")}${trailingSlash ? "/?" : ""}$`),
+    params
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compilePathPattern, "compilePathPattern");
+function compileMatcherPattern(pattern) {
+  if (typeof pattern === "string" && pattern !== "*" && !pattern.endsWith("(.*)")) {
+    return compilePathPattern(pattern, true);
+  }
+  return compilePattern(pattern);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compileMatcherPattern, "compileMatcherPattern");
+function compilePattern(pattern) {
+  if (pattern instanceof RegExp) {
+    return { kind: "regexp", regex: pattern };
+  }
+  if (pattern === "*" || pattern === "/(.*)") {
+    return { kind: "all" };
+  }
+  if (pattern.endsWith("(.*)")) {
+    return {
+      kind: "subtree",
+      prefix: pattern.slice(0, -4).replace(/\/$/, "")
+    };
+  }
+  return compilePathPattern(pattern);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compilePattern, "compilePattern");
+function compileMiddlewareConfig(config) {
+  const compiled = {
+    matcher: config.matcher ? toMatcherList(config.matcher).map(
+      (matcher) => typeof matcher === "function" ? matcher : compileMatcherPattern(matcher)
+    ) : void 0,
+    exclude: _optionalChain([config, 'access', _4 => _4.exclude, 'optionalAccess', _5 => _5.map, 'call', _6 => _6(compilePattern)])
+  };
+  compiledConfigCache.set(config, {
+    compiled,
+    matcher: config.matcher,
+    matcherEntries: Array.isArray(config.matcher) ? config.matcher.slice() : void 0,
+    excludeEntries: _optionalChain([config, 'access', _7 => _7.exclude, 'optionalAccess', _8 => _8.slice, 'call', _9 => _9()])
+  });
+  return compiled;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compileMiddlewareConfig, "compileMiddlewareConfig");
+function matchPattern(pattern, pathname) {
+  if (pattern.kind === "all") {
+    return { matched: true };
+  }
+  if (pattern.kind === "subtree") {
+    return {
+      matched: pathname === pattern.prefix || pathname.startsWith(`${pattern.prefix}/`)
+    };
+  }
+  pattern.regex.lastIndex = 0;
+  const match = pattern.regex.exec(pathname);
+  if (!match) {
+    return { matched: false };
+  }
+  if (pattern.kind === "regexp") {
+    return {
+      matched: true,
+      params: match.groups ? { ...match.groups } : void 0
+    };
+  }
+  const values = {};
+  pattern.params.forEach((param, index) => {
+    values[param] = match[index + 1] || "";
+  });
+  return {
+    matched: true,
+    params: Object.keys(values).length > 0 ? values : void 0
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchPattern, "matchPattern");
+function matchesCompiledMiddlewareConfig(pathname, config, ctx) {
+  let canonicalPathname;
+  const getCanonicalPathname = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => _nullishCoalesce(canonicalPathname, () => ( (canonicalPathname = _chunkUS2QVW3Ecjs.canonicalizeRequestPathname.call(void 0, pathname)))), "getCanonicalPathname");
+  if (config.exclude) {
+    for (const pattern of config.exclude) {
+      if (matchPattern(pattern, getCanonicalPathname()).matched) {
+        return { matched: false };
+      }
+    }
+  }
+  if (config.matcher) {
+    for (const matcher of config.matcher) {
+      if (typeof matcher === "function") {
+        if (matcher(ctx)) {
+          return { matched: true };
+        }
+        continue;
+      }
+      const result = matchPattern(matcher, getCanonicalPathname());
+      if (result.matched) {
+        return result;
+      }
+    }
+    return { matched: false };
+  }
+  return { matched: true };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesCompiledMiddlewareConfig, "matchesCompiledMiddlewareConfig");
+function matchesMiddlewareConfig(pathname, config, ctx) {
+  const cached = compiledConfigCache.get(config);
+  const unchanged = cached && (Array.isArray(config.matcher) ? sameEntries(config.matcher, cached.matcherEntries) : config.matcher === cached.matcher) && sameEntries(config.exclude, cached.excludeEntries);
+  const compiled = unchanged ? cached.compiled : compileMiddlewareConfig(config);
+  return matchesCompiledMiddlewareConfig(pathname, compiled, ctx);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesMiddlewareConfig, "matchesMiddlewareConfig");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports._clearCurrentMiddlewareData = _clearCurrentMiddlewareData; exports._clearCurrentMiddlewareContext = _clearCurrentMiddlewareContext; exports._runWithMiddlewareData = _runWithMiddlewareData; exports._runWithMiddlewareContext = _runWithMiddlewareContext; exports.getMiddlewareData = getMiddlewareData; exports.getMiddlewareValue = getMiddlewareValue; exports.getMiddlewareContext = getMiddlewareContext; exports.parseMiddlewareCookieHeader = parseMiddlewareCookieHeader; exports.serializeMiddlewareCookie = serializeMiddlewareCookie; exports.serializeMiddlewareCookieDeletion = serializeMiddlewareCookieDeletion; exports.normalizeMiddlewareModule = normalizeMiddlewareModule; exports.compileMiddlewareRoute = compileMiddlewareRoute; exports.matchesMiddlewareRoute = matchesMiddlewareRoute; exports.compileMiddlewareConfig = compileMiddlewareConfig; exports.matchesMiddlewareConfig = matchesMiddlewareConfig;