@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-GZTUT75U.mjs

@@ -1,293 +0,0 @@
-import {
-  FARM_ANONYMOUS_CLIENT_ADDRESS
-} from "./chunk-BRYPZIMB.mjs";
-import {
-  FARM_MARKDOWN_PAGE_CHECK_HEADER,
-  _getFarmMarkdownPageCheckToken,
-  createFarmMarkdownViewResponse,
-  requestAcceptsMarkdown
-} from "./chunk-I6UVKUYK.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/app-markdown-runtime.ts
-import { pathToFileURL } from "url";
-function isFarmMarkdownPageFile(filePath) {
-  return /(^|[/\\])page\.mdx?$/i.test(filePath);
-}
-__name(isFarmMarkdownPageFile, "isFarmMarkdownPageFile");
-function normalizeFarmMarkdownRoutePath(pathname) {
-  const withoutExtension = pathname.replace(/\.md$/i, "");
-  const normalized = withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
-  return normalized === "/index" ? "/" : normalized.replace(/\/+$/g, "") || "/";
-}
-__name(normalizeFarmMarkdownRoutePath, "normalizeFarmMarkdownRoutePath");
-function parseMarkdownFrontmatter(source) {
-  if (!source.startsWith("---")) {
-    return { frontmatter: {}, body: source };
-  }
-  const endIndex = source.indexOf("\n---", 3);
-  if (endIndex === -1) {
-    return { frontmatter: {}, body: source };
-  }
-  const frontmatterSource = source.slice(3, endIndex).trim();
-  const closingFenceEnd = endIndex + "\n---".length;
-  const bodyStart = source.slice(closingFenceEnd, closingFenceEnd + 2) === "\r\n" ? closingFenceEnd + 2 : source[closingFenceEnd] === "\n" ? closingFenceEnd + 1 : closingFenceEnd;
-  const body = source.slice(bodyStart);
-  const frontmatter = {};
-  for (const line of frontmatterSource.split(/\r?\n/)) {
-    const separator = line.indexOf(":");
-    if (separator === -1) continue;
-    const key = line.slice(0, separator).trim();
-    const value = line.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
-    if (key && value) frontmatter[key] = value;
-  }
-  return { frontmatter, body };
-}
-__name(parseMarkdownFrontmatter, "parseMarkdownFrontmatter");
-function titleFromMarkdown(body, fallback) {
-  return body.match(/^#\s+(.+)$/m)?.[1]?.trim() || fallback;
-}
-__name(titleFromMarkdown, "titleFromMarkdown");
-function createMarkdownMetadata(source, filePath) {
-  const { frontmatter, body } = parseMarkdownFrontmatter(source);
-  const routeTitle = titleFromMarkdown(body);
-  const title = frontmatter.title || routeTitle;
-  const description = frontmatter.description;
-  if (!title && !description) {
-    return void 0;
-  }
-  return {
-    ...title ? { title } : {},
-    ...description ? { description } : {},
-    source: filePath
-  };
-}
-__name(createMarkdownMetadata, "createMarkdownMetadata");
-async function evaluateMdxSource(source, filePath) {
-  const [{ evaluate }, runtime, remarkGfmModule] = await Promise.all([
-    import("@mdx-js/mdx"),
-    import("react/jsx-runtime"),
-    import("remark-gfm")
-  ]);
-  const remarkGfm = remarkGfmModule.default;
-  return evaluate(source, {
-    ...runtime,
-    baseUrl: pathToFileURL(filePath),
-    remarkPlugins: [remarkGfm]
-  });
-}
-__name(evaluateMdxSource, "evaluateMdxSource");
-function createFarmMarkdownRouteModule(input) {
-  const { body } = parseMarkdownFrontmatter(input.source);
-  const components = input.components || {};
-  const className = input.config?.className || "farm-markdown";
-  let evaluatedPromise;
-  const loadContent = /* @__PURE__ */ __name(async () => {
-    evaluatedPromise ?? (evaluatedPromise = evaluateMdxSource(body, input.filePath));
-    return evaluatedPromise;
-  }, "loadContent");
-  async function FarmMarkdownPage(props) {
-    const { createElement } = await import("react");
-    const evaluated = await loadContent();
-    const MDXContent = evaluated.default;
-    return createElement(
-      "article",
-      { className, "data-farm-markdown-page": "" },
-      createElement(MDXContent, {
-        ...props,
-        components: {
-          ...components,
-          ...props?.components
-        }
-      })
-    );
-  }
-  __name(FarmMarkdownPage, "FarmMarkdownPage");
-  return {
-    default: FarmMarkdownPage,
-    metadata: createMarkdownMetadata(input.source, input.filePath),
-    source: input.source
-  };
-}
-__name(createFarmMarkdownRouteModule, "createFarmMarkdownRouteModule");
-var publicSourceResponses = /* @__PURE__ */ new WeakSet();
-function isFarmMarkdownPublicSourceResponse(response) {
-  return publicSourceResponses.has(response);
-}
-__name(isFarmMarkdownPublicSourceResponse, "isFarmMarkdownPublicSourceResponse");
-var ANONYMOUS_REQUEST_HEADERS = /* @__PURE__ */ new Set([
-  "accept",
-  "accept-encoding",
-  "accept-language",
-  "cache-control",
-  "connection",
-  "dnt",
-  "host",
-  "if-match",
-  "if-modified-since",
-  "if-none-match",
-  "if-range",
-  "if-unmodified-since",
-  "keep-alive",
-  "origin",
-  "pragma",
-  "priority",
-  "purpose",
-  "range",
-  "referer",
-  "save-data",
-  "sec-gpc",
-  "sec-purpose",
-  "te",
-  "traceparent",
-  "tracestate",
-  "upgrade-insecure-requests",
-  "user-agent",
-  "x-forwarded-host",
-  "x-forwarded-port",
-  "x-forwarded-proto",
-  "x-request-id"
-]);
-function isAnonymousRequestHeader(name) {
-  const lower = name.toLowerCase();
-  return ANONYMOUS_REQUEST_HEADERS.has(lower) || lower.startsWith("sec-fetch-") || lower.startsWith("sec-ch-");
-}
-__name(isAnonymousRequestHeader, "isAnonymousRequestHeader");
-var PAGE_CHECK_DROPPED_HEADERS = /* @__PURE__ */ new Set([
-  "accept-encoding",
-  "if-match",
-  "if-modified-since",
-  "if-none-match",
-  "if-range",
-  "if-unmodified-since",
-  "range"
-]);
-var PAGE_SEGMENT_MARKER = /<div\s[^>]*\bid=["']?__farm_page__["'\s>]/i;
-async function anonymousVisitorOpensPage(options, url, targetPathname) {
-  const pageUrl = new URL(url);
-  pageUrl.pathname = targetPathname;
-  const headers = new Headers();
-  for (const [name, value] of options.request.headers) {
-    if (!PAGE_CHECK_DROPPED_HEADERS.has(name.toLowerCase())) headers.append(name, value);
-  }
-  headers.set("accept", "text/html");
-  headers.set(FARM_MARKDOWN_PAGE_CHECK_HEADER, _getFarmMarkdownPageCheckToken());
-  const response = await options.renderPage(
-    new Request(pageUrl, {
-      method: "GET",
-      headers,
-      redirect: "manual",
-      signal: options.request.signal
-    })
-  );
-  if (response.status < 200 || response.status >= 300 || !response.headers.get("content-type")?.toLowerCase().includes("text/html")) {
-    void response.body?.cancel().catch(() => {
-    });
-    return false;
-  }
-  return PAGE_SEGMENT_MARKER.test(await response.text());
-}
-__name(anonymousVisitorOpensPage, "anonymousVisitorOpensPage");
-function hasOnlyAnonymousHeaders(headers) {
-  for (const name of headers.keys()) {
-    if (!isAnonymousRequestHeader(name)) return false;
-  }
-  return true;
-}
-__name(hasOnlyAnonymousHeaders, "hasOnlyAnonymousHeaders");
-var FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS = FARM_ANONYMOUS_CLIENT_ADDRESS;
-async function createFarmMarkdownSourceResponse(options) {
-  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
-    return null;
-  }
-  if (options.config?.markdownRoutes === false) {
-    return null;
-  }
-  const url = new URL(options.request.url);
-  const hasMarkdownExtension = url.pathname.toLowerCase().endsWith(".md");
-  if (!hasMarkdownExtension && !requestAcceptsMarkdown(options.request.headers.get("accept"))) {
-    return null;
-  }
-  const targetPathname = normalizeFarmMarkdownRoutePath(url.pathname);
-  const source = await options.resolveSource(targetPathname);
-  if (!source) {
-    return null;
-  }
-  const anonymous = hasOnlyAnonymousHeaders(options.request.headers) && (!options.clientAddress || options.clientAddress === FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS);
-  if (options.renderPage && (hasMarkdownExtension || !anonymous)) {
-    const publicUrl = new URL(url);
-    publicUrl.pathname = targetPathname;
-    const publicHeaders = new Headers();
-    for (const [name, value] of options.request.headers) {
-      if (isAnonymousRequestHeader(name)) publicHeaders.append(name, value);
-    }
-    publicHeaders.set("accept", "text/markdown");
-    const publicResponse = await options.renderPage(
-      new Request(publicUrl, {
-        method: options.request.method,
-        headers: publicHeaders,
-        signal: options.request.signal
-      })
-    );
-    if (publicResponse.headers.get("X-Farm-Markdown-Route") === targetPathname && publicResponse.headers.has("X-Farm-Markdown-Source")) {
-      let response = publicResponse;
-      if (options.request.headers.has("cookie") || options.request.headers.has("authorization")) {
-        const headers2 = new Headers(publicResponse.headers);
-        headers2.set("Cache-Control", "private, no-store");
-        response = new Response(publicResponse.body, {
-          status: publicResponse.status,
-          statusText: publicResponse.statusText,
-          headers: headers2
-        });
-      }
-      publicSourceResponses.add(response);
-      return response;
-    }
-    await publicResponse.body?.cancel();
-    if (!hasMarkdownExtension) return null;
-    return new Response(`No public Markdown version of ${targetPathname}.
-`, {
-      status: 404,
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8",
-        "Cache-Control": "private, no-store"
-      }
-    });
-  }
-  if (options.renderPage && !await anonymousVisitorOpensPage(options, url, targetPathname)) {
-    return null;
-  }
-  const headers = new Headers({
-    "Content-Type": "text/markdown; charset=utf-8",
-    "Content-Location": targetPathname === "/" ? "/index.md" : `${targetPathname}.md`,
-    "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
-    "X-Farm-Markdown-Route": targetPathname,
-    "X-Farm-Markdown-Source": source.filePath
-  });
-  if (!hasMarkdownExtension) {
-    headers.set("Vary", "Accept");
-  }
-  return createFarmMarkdownViewResponse({
-    request: options.request,
-    requestUrl: url,
-    markdown: source.source,
-    status: 200,
-    headers,
-    markdownPath: headers.get("Content-Location")
-  });
-}
-__name(createFarmMarkdownSourceResponse, "createFarmMarkdownSourceResponse");
-
-export {
-  isFarmMarkdownPageFile,
-  normalizeFarmMarkdownRoutePath,
-  parseMarkdownFrontmatter,
-  titleFromMarkdown,
-  createMarkdownMetadata,
-  createFarmMarkdownRouteModule,
-  isFarmMarkdownPublicSourceResponse,
-  FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS,
-  createFarmMarkdownSourceResponse
-};

package/dist/chunk-GZWHCWLB.mjs

@@ -1,186 +0,0 @@
-import {
-  compileMiddlewareConfig,
-  matchesCompiledMiddlewareConfig
-} from "./chunk-HKFBMHCD.mjs";
-import {
-  createFarmAPIMiddlewarePathnames,
-  resolveFarmAPIServerBasePath
-} from "./chunk-BTHHUD7Q.mjs";
-import {
-  canonicalizeRequestPathSegments,
-  canonicalizeRequestPathname
-} from "./chunk-CQ6OSQ3K.mjs";
-import {
-  resolveFarmLocalePath
-} from "./chunk-L3KT7IXV.mjs";
-import {
-  stripFarmBasePath
-} from "./chunk-4RB44K6Z.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/integration-middleware-matcher.ts
-function isFarmIntegration(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-integration";
-}
-__name(isFarmIntegration, "isFarmIntegration");
-var compiledIntegrationGuards = /* @__PURE__ */ new WeakMap();
-var noMiddlewareContext = {};
-function resolveIntegrationMiddlewareParams(entry, pathname, config) {
-  const params = resolveMatcherParams(entry.matcher, pathname);
-  if (params || !entry.matcher) return params;
-  const routePathname = resolveIntegrationRoutePathname(pathname, config);
-  const candidates = [.../* @__PURE__ */ new Set([pathname, ...getIntegrationAPIPathnames(config)(routePathname)])];
-  for (const candidate of candidates) {
-    if (candidate === pathname) continue;
-    const routeParams = resolveMatcherParams(entry.matcher, candidate);
-    if (routeParams) return routeParams;
-  }
-  let compiled = compiledIntegrationGuards.get(entry);
-  if (!compiled) {
-    compiled = compileMiddlewareConfig({
-      matcher: typeof entry.matcher === "string" ? entry.matcher : [...entry.matcher]
-    });
-    compiledIntegrationGuards.set(entry, compiled);
-  }
-  for (const candidate of candidates) {
-    const result = matchesCompiledMiddlewareConfig(candidate, compiled, noMiddlewareContext);
-    if (result.matched) return result.params ?? {};
-  }
-  return null;
-}
-__name(resolveIntegrationMiddlewareParams, "resolveIntegrationMiddlewareParams");
-function integrationMiddlewareMayHandlePath(integrations, pathname, catchAllProbe) {
-  if (!integrations) return false;
-  const covers = /* @__PURE__ */ __name((entry) => resolveIntegrationMiddlewareParams(entry, pathname, void 0) !== null, "covers");
-  return Object.values(integrations).some(
-    (integration) => isFarmIntegration(integration) && (integration.middleware || []).some((entry) => {
-      if (catchAllProbe === void 0) return covers(entry);
-      if (!entry.matcher) return false;
-      const specific = (Array.isArray(entry.matcher) ? entry.matcher : [entry.matcher]).filter(
-        (matcher) => resolveIntegrationMiddlewareParams({ matcher }, catchAllProbe, void 0) === null
-      );
-      return specific.length > 0 && covers({ matcher: specific });
-    })
-  );
-}
-__name(integrationMiddlewareMayHandlePath, "integrationMiddlewareMayHandlePath");
-var FARM_INTEGRATION_API_BASE_PATH_KEY = "__farmAPIServerBasePath";
-var integrationAPIPathnames = /* @__PURE__ */ new WeakMap();
-function getIntegrationAPIPathnames(config) {
-  if (!config) return (pathname) => [pathname];
-  let toPathnames = integrationAPIPathnames.get(config);
-  if (!toPathnames) {
-    const recorded = config[FARM_INTEGRATION_API_BASE_PATH_KEY];
-    const api = config.api;
-    const serverBasePath = typeof recorded === "string" ? recorded : typeof api?.baseURL === "string" && typeof api.basePath === "string" ? resolveFarmAPIServerBasePath(api) : void 0;
-    toPathnames = createFarmAPIMiddlewarePathnames(serverBasePath);
-    integrationAPIPathnames.set(config, toPathnames);
-  }
-  return toPathnames;
-}
-__name(getIntegrationAPIPathnames, "getIntegrationAPIPathnames");
-function resolveIntegrationRoutePathname(pathname, config) {
-  const basePath = typeof config?.basePath === "string" ? config.basePath : void 0;
-  let routePathname = basePath ? stripFarmBasePath(pathname, basePath) : pathname;
-  const i18n = config?.i18n;
-  if (i18n && Array.isArray(i18n.locales) && i18n.locales.length > 0) {
-    routePathname = resolveFarmLocalePath(routePathname, {
-      locales: i18n.locales,
-      defaultLocale: i18n.defaultLocale,
-      routing: i18n.routing || "prefix-except-default"
-    }).pathname;
-  }
-  return routePathname;
-}
-__name(resolveIntegrationRoutePathname, "resolveIntegrationRoutePathname");
-function resolveMatcherParams(matcher, pathname) {
-  if (!matcher) {
-    return {};
-  }
-  const list = Array.isArray(matcher) ? matcher : [matcher];
-  let canonicalPathname;
-  let canonicalSegments;
-  for (const item of list) {
-    if (item === "/(.*)" || item === "*") {
-      return {};
-    }
-    if (item.endsWith("(.*)")) {
-      canonicalPathname ?? (canonicalPathname = canonicalizeRequestPathname(pathname));
-      const prefix = item.slice(0, -4);
-      if (canonicalPathname === prefix || canonicalPathname.startsWith(`${prefix}/`)) {
-        return {};
-      }
-      continue;
-    }
-    canonicalSegments ?? (canonicalSegments = canonicalizeRequestPathSegments(pathname));
-    const params = matchPathSegments(splitPath(item), canonicalSegments);
-    if (params) {
-      return params;
-    }
-  }
-  return null;
-}
-__name(resolveMatcherParams, "resolveMatcherParams");
-function matchPathSegments(routeSegments, pathSegments) {
-  const params = {};
-  let routeIndex = 0;
-  let pathIndex = 0;
-  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
-    const routeSegment = routeSegments[routeIndex];
-    const pathSegment = pathSegments[pathIndex];
-    if (isCatchAllSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex);
-      return params;
-    }
-    if (isDynamicSegment(routeSegment)) {
-      params[getSegmentParamName(routeSegment)] = pathSegment;
-      routeIndex += 1;
-      pathIndex += 1;
-      continue;
-    }
-    if (routeSegment !== pathSegment) {
-      return null;
-    }
-    routeIndex += 1;
-    pathIndex += 1;
-  }
-  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
-    return params;
-  }
-  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
-    params[getSegmentParamName(routeSegments[routeIndex])] = [];
-    return params;
-  }
-  return null;
-}
-__name(matchPathSegments, "matchPathSegments");
-function splitPath(value) {
-  return value.split("/").filter(Boolean);
-}
-__name(splitPath, "splitPath");
-function isDynamicSegment(segment) {
-  return segment.startsWith("[") && segment.endsWith("]");
-}
-__name(isDynamicSegment, "isDynamicSegment");
-function isCatchAllSegment(segment) {
-  return segment.startsWith("[...") && segment.endsWith("]");
-}
-__name(isCatchAllSegment, "isCatchAllSegment");
-function getSegmentParamName(segment) {
-  if (isCatchAllSegment(segment)) {
-    return segment.slice(4, -1);
-  }
-  return segment.slice(1, -1);
-}
-__name(getSegmentParamName, "getSegmentParamName");
-
-export {
-  isFarmIntegration,
-  resolveIntegrationMiddlewareParams,
-  integrationMiddlewareMayHandlePath,
-  FARM_INTEGRATION_API_BASE_PATH_KEY,
-  matchPathSegments,
-  splitPath
-};

package/dist/chunk-H3EGVQE5.mjs

@@ -1,22 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/plugin-integration-context.ts
-var FARM_PLUGIN_INTEGRATION_CONTEXT = /* @__PURE__ */ Symbol.for("@farm.js/core/plugin-integration-context");
-function setFarmPluginIntegrationContext(plugin, integration) {
-  Object.defineProperty(plugin, FARM_PLUGIN_INTEGRATION_CONTEXT, {
-    value: integration
-  });
-}
-__name(setFarmPluginIntegrationContext, "setFarmPluginIntegrationContext");
-function getFarmPluginIntegrationContext(plugin) {
-  const value = plugin[FARM_PLUGIN_INTEGRATION_CONTEXT];
-  return value && typeof value === "object" ? value : void 0;
-}
-__name(getFarmPluginIntegrationContext, "getFarmPluginIntegrationContext");
-
-export {
-  setFarmPluginIntegrationContext,
-  getFarmPluginIntegrationContext
-};