@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-AFOD3LYZ.cjs

@@ -0,0 +1,377 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _chunkIAMRBF3Zcjs = require('./chunk-IAMRBF3Z.cjs');
+
+
+var _chunk2CQ74SP6cjs = require('./chunk-2CQ74SP6.cjs');
+
+
+var _chunkUJ2C4ICScjs = require('./chunk-UJ2C4ICS.cjs');
+
+
+
+
+
+
+
+var _chunk4PNUXIVUcjs = require('./chunk-4PNUXIVU.cjs');
+
+
+var _chunkWMAPPDMMcjs = require('./chunk-WMAPPDMM.cjs');
+
+
+var _chunk6V4TDWECcjs = require('./chunk-6V4TDWEC.cjs');
+
+
+
+var _chunkMKB2EGIRcjs = require('./chunk-MKB2EGIR.cjs');
+
+
+var _chunkVQDBNVOOcjs = require('./chunk-VQDBNVOO.cjs');
+
+
+var _chunk5QIKR7RRcjs = require('./chunk-5QIKR7RR.cjs');
+
+
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/route-manager.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var _APIRouteConflictError = class _APIRouteConflictError extends Error {
+  constructor(routePath, method, existingFile, conflictingFile) {
+    super(
+      `Duplicate API route for ${method.toUpperCase()} ${routePath}: ${existingFile} conflicts with ${conflictingFile}`
+    );
+    this.name = "APIRouteConflictError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _APIRouteConflictError, "APIRouteConflictError");
+var APIRouteConflictError = _APIRouteConflictError;
+var _APIRouteManager = class _APIRouteManager {
+  constructor(appDir, viteServer, options = {}) {
+    this.routes = /* @__PURE__ */ new Map();
+    this.endpointSources = /* @__PURE__ */ new Map();
+    this.routeShapes = /* @__PURE__ */ new Map();
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.viteServer = viteServer;
+    this.plugins = _nullishCoalesce(options.plugins, () => ( []));
+    this.throwOnLoadError = options.throwOnLoadError === true;
+    this.i18n = options.i18n;
+    this.bodySizeLimit = options.bodySizeLimit;
+    this.basePath = options.basePath;
+  }
+  /**
+   * Discover route.ts files in /app/api and explicit endpoints in root routes.ts
+   */
+  async discoverRoutes() {
+    const previousRoutes = this.routes;
+    const previousEndpointSources = this.endpointSources;
+    const previousRouteShapes = this.routeShapes;
+    this.routes = /* @__PURE__ */ new Map();
+    this.endpointSources = /* @__PURE__ */ new Map();
+    this.routeShapes = /* @__PURE__ */ new Map();
+    try {
+      for (const appDir of this.appDirs) {
+        const apiDir = path.join(appDir, "api");
+        let routeFiles = [];
+        if (fs.existsSync(apiDir)) {
+          routeFiles = this.findRouteFiles(apiDir);
+        }
+        for (const filePath of routeFiles) {
+          await this.loadRoute(filePath, appDir);
+        }
+        await this.loadRootRoutes(appDir);
+        await this.loadProgrammaticApiRoutes(appDir);
+      }
+      this.routes = new Map(
+        _chunk4PNUXIVUcjs.mergePluginAPIRoutes.call(void 0, [...this.routes.values()], this.plugins, void 0, {
+          bodySizeLimit: this.bodySizeLimit
+        }).map((route) => [route.path, route])
+      );
+    } catch (error) {
+      this.routes = previousRoutes;
+      this.endpointSources = previousEndpointSources;
+      this.routeShapes = previousRouteShapes;
+      throw error;
+    }
+    if (process.env.FARM_VERBOSE) {
+      _chunk5QIKR7RRcjs.logger.success(`Discovered ${this.routes.size} API routes`);
+      for (const [routePath, route] of this.routes) {
+        _chunk5QIKR7RRcjs.logger.info(`  ${route.methods.join(", ")} ${routePath}`);
+      }
+    }
+  }
+  /**
+   * Recursively find all route.ts files
+   */
+  findRouteFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findRouteFiles(fullPath));
+      } else if (_chunk2CQ74SP6cjs.isFarmAPIRouteFileName.call(void 0, entry.name)) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  /**
+   * Load a route.ts file and extract HTTP method exports
+   */
+  async loadRoute(filePath, appDir) {
+    try {
+      const apiDir = path.join(appDir, "api");
+      const relativePath = path.relative(apiDir, path.dirname(filePath));
+      const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+      const routeModule = await this.loadModule(filePath);
+      const endpoints = {};
+      const availableMethods = [];
+      for (const method of _chunk4PNUXIVUcjs.API_ROUTE_METHODS) {
+        if (routeModule[method]) {
+          endpoints[method] = routeModule[method];
+          availableMethods.push(method);
+        }
+      }
+      if (availableMethods.length > 0) {
+        const existingSources = this.endpointSources.get(routePath);
+        if (existingSources) {
+          for (const method of availableMethods) {
+            const existingSource = existingSources.get(method);
+            if (_optionalChain([existingSource, 'optionalAccess', _ => _.appDir]) === appDir) {
+              throw new APIRouteConflictError(routePath, method, existingSource.filePath, filePath);
+            }
+          }
+        }
+        const runtimeConfig = _chunkMKB2EGIRcjs.normalizeFarmRouteRuntimeConfig.call(void 0, 
+          _chunkMKB2EGIRcjs.getFarmRouteRuntimeConfig.call(void 0, routeModule),
+          `API route "${routePath}"`
+        );
+        this.registerRouteShape(routePath, filePath, appDir);
+        const existingRoute = this.routes.get(routePath);
+        const mergedMethods = existingRoute ? [...existingRoute.methods] : [];
+        for (const method of availableMethods) {
+          if (!mergedMethods.includes(method)) mergedMethods.push(method);
+        }
+        this.routes.set(routePath, {
+          ...existingRoute,
+          path: routePath,
+          filePath,
+          methods: mergedMethods,
+          endpoints: { ..._optionalChain([existingRoute, 'optionalAccess', _2 => _2.endpoints]), ...endpoints },
+          ...runtimeConfig
+        });
+        const nextSources = new Map(existingSources);
+        for (const method of availableMethods) {
+          nextSources.set(method, { appDir, filePath });
+        }
+        this.endpointSources.set(routePath, nextSources);
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading route ${filePath}`, error);
+    }
+  }
+  /**
+   * Load explicit-path endpoints from src/routes.ts-style files.
+   */
+  async loadRootRoutes(appDir) {
+    const routesFile = this.findRootRoutesFile(appDir);
+    if (!routesFile) {
+      return;
+    }
+    try {
+      const routesModule = await this.loadModule(routesFile);
+      for (const exportValue of Object.values(routesModule)) {
+        const endpoint = exportValue;
+        if (!_optionalChain([endpoint, 'optionalAccess', _3 => _3.__path])) {
+          continue;
+        }
+        const method = String(endpoint.__method || "GET").toUpperCase();
+        this.registerRouteShape(endpoint.__path, routesFile, appDir);
+        this.addEndpoint(endpoint.__path, routesFile, method, endpoint, appDir);
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading root API routes ${routesFile}`, error);
+    }
+  }
+  async loadProgrammaticApiRoutes(appDir) {
+    const candidateRoots = [path.dirname(appDir), appDir];
+    const routeFiles = Array.from(
+      new Set(candidateRoots.flatMap((srcRoot) => _chunkIAMRBF3Zcjs.findProgrammaticRouteFilesInDir.call(void 0, srcRoot)))
+    );
+    if (routeFiles.length === 0) return;
+    const { getProgrammaticRouteManifest } = await import("./routes.cjs");
+    for (const routeFile of routeFiles) {
+      try {
+        const routesModule = await this.loadModule(routeFile);
+        const manifest = getProgrammaticRouteManifest(routesModule);
+        if (!manifest) continue;
+        for (const definition of manifest.routes) {
+          if (definition.kind !== "api") continue;
+          if (!Object.values(definition.methods).some(Boolean)) continue;
+          this.addProgrammaticApiRoute(routeFile, definition, appDir);
+        }
+      } catch (error) {
+        this.handleLoadError(`Error loading programmatic API routes ${routeFile}`, error);
+      }
+    }
+  }
+  handleLoadError(message, error) {
+    _chunk5QIKR7RRcjs.logger.error(`${message}: ${error}`);
+    if (this.throwOnLoadError || error instanceof APIRouteConflictError || error instanceof _chunkNO3WWW3Ncjs.AmbiguousRouteError || error instanceof _chunkNO3WWW3Ncjs.NonTerminalCatchAllRouteError) {
+      throw error;
+    }
+  }
+  findRootRoutesFile(appDir) {
+    const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
+    const candidateDirs = [path.dirname(appDir), appDir];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of candidateDirs) {
+      for (const routeName of routeNames) {
+        const routesFile = path.join(dir, routeName);
+        if (seen.has(routesFile)) {
+          continue;
+        }
+        seen.add(routesFile);
+        if (fs.existsSync(routesFile)) {
+          return routesFile;
+        }
+      }
+    }
+    return null;
+  }
+  async loadModule(filePath) {
+    if (this.viteServer) {
+      return await this.viteServer.ssrLoadModule(filePath);
+    }
+    return await import(
+      /* @vite-ignore */
+      _chunkVQDBNVOOcjs.toFileModuleUrl.call(void 0, filePath)
+    );
+  }
+  addEndpoint(routePath, filePath, method, endpoint, appDir, runtimeConfig = {}) {
+    const normalizedMethod = method.toUpperCase();
+    const existingRoute = this.routes.get(routePath);
+    const existingSource = _optionalChain([this, 'access', _4 => _4.endpointSources, 'access', _5 => _5.get, 'call', _6 => _6(routePath), 'optionalAccess', _7 => _7.get, 'call', _8 => _8(normalizedMethod)]);
+    if (_optionalChain([existingSource, 'optionalAccess', _9 => _9.appDir]) === appDir) {
+      throw new APIRouteConflictError(
+        routePath,
+        normalizedMethod,
+        existingSource.filePath,
+        filePath
+      );
+    }
+    if (existingRoute) {
+      if (!existingRoute.methods.includes(normalizedMethod)) {
+        existingRoute.methods.push(normalizedMethod);
+      }
+      existingRoute.endpoints[normalizedMethod] = endpoint;
+      Object.assign(existingRoute, runtimeConfig);
+      const sources = _nullishCoalesce(this.endpointSources.get(routePath), () => ( /* @__PURE__ */ new Map()));
+      sources.set(normalizedMethod, { appDir, filePath });
+      this.endpointSources.set(routePath, sources);
+      return;
+    }
+    this.routes.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint },
+      ...runtimeConfig
+    });
+    this.endpointSources.set(routePath, /* @__PURE__ */ new Map([[normalizedMethod, { appDir, filePath }]]));
+  }
+  addProgrammaticApiRoute(filePath, route, appDir) {
+    const modulePath = _chunk6V4TDWECcjs.createProgrammaticRouteModuleId.call(void 0, filePath, "api", route.path);
+    const runtimeConfig = _chunkMKB2EGIRcjs.normalizeFarmRouteRuntimeConfig.call(void 0, route, `API route "${route.path}"`);
+    for (const [method, endpoint] of Object.entries(route.methods)) {
+      if (endpoint) {
+        this.addEndpoint(route.path, modulePath, method, endpoint, appDir, runtimeConfig);
+      }
+    }
+  }
+  registerRouteShape(routePath, filePath, appDir) {
+    const replacedPath = _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, this.routeShapes, routePath, filePath, appDir);
+    if (replacedPath) {
+      this.routes.delete(replacedPath);
+      this.endpointSources.delete(replacedPath);
+    }
+  }
+  /**
+   * Get the handler that directly invokes endpoint handlers
+   */
+  getHandler(options = {}) {
+    if (this.routes.size === 0) {
+      return null;
+    }
+    return async (request) => {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      const method = request.method.toUpperCase();
+      const match = _chunk4PNUXIVUcjs.matchAPIRouteAtBasePath.call(void 0, this.routes, pathname, this.basePath);
+      if (!match) {
+        return new Response(JSON.stringify({ error: "Not Found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const { route, params } = match;
+      const endpoint = _chunk4PNUXIVUcjs.resolveAPIRouteEndpoint.call(void 0, route, method);
+      if (!endpoint) {
+        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+          status: 405,
+          headers: {
+            Allow: _chunk4PNUXIVUcjs.getAllowedAPIRouteMethods.call(void 0, route).join(", "),
+            "Content-Type": "application/json"
+          }
+        });
+      }
+      const invoke = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+        try {
+          return await _chunk4PNUXIVUcjs.invokeAPIRouteEndpoint.call(void 0, endpoint, request, params, this.bodySizeLimit);
+        } catch (error) {
+          if (options.throwOnError) throw error;
+          console.error(`[API Error] ${pathname}:`, error);
+          return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }, "invoke");
+      return _optionalChain([this, 'access', _10 => _10.i18n, 'optionalAccess', _11 => _11.config, 'access', _12 => _12.enabled]) ? _chunkUJ2C4ICScjs._runWithFarmI18nRequest.call(void 0, this.i18n, request, invoke, {
+        redirect: false
+      }) : invoke();
+    };
+  }
+  /**
+   * Check if a path is an API route
+   */
+  isAPIRoute(pathname) {
+    return Boolean(this.matchRoute(pathname));
+  }
+  matchRoute(pathname) {
+    return _chunk4PNUXIVUcjs.matchAPIRouteAtBasePath.call(void 0, this.routes, pathname, this.basePath);
+  }
+  /**
+   * Get all routes for client type generation
+   */
+  getRoutes() {
+    return this.routes;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _APIRouteManager, "APIRouteManager");
+var APIRouteManager = _APIRouteManager;
+
+
+
+
+exports.APIRouteConflictError = APIRouteConflictError; exports.APIRouteManager = APIRouteManager;

package/dist/chunk-AH7HOAQ3.cjs

@@ -0,0 +1,151 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _chunkBBVSJVBZcjs = require('./chunk-BBVSJVBZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/app-markdown-runtime.ts
+var _url = require('url');
+function isFarmMarkdownPageFile(filePath) {
+  return /(^|[/\\])page\.mdx?$/i.test(filePath);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmMarkdownPageFile, "isFarmMarkdownPageFile");
+function normalizeFarmMarkdownRoutePath(pathname) {
+  const withoutExtension = pathname.replace(/\.md$/i, "");
+  const normalized = withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
+  return normalized === "/index" ? "/" : normalized.replace(/\/+$/g, "") || "/";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseMarkdownFrontmatter, "parseMarkdownFrontmatter");
+function titleFromMarkdown(body, fallback) {
+  return _optionalChain([body, 'access', _ => _.match, 'call', _2 => _2(/^#\s+(.+)$/m), 'optionalAccess', _3 => _3[1], 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]) || fallback;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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: _url.pathToFileURL.call(void 0, filePath),
+    remarkPlugins: [remarkGfm]
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, evaluateMdxSource, "evaluateMdxSource");
+function createFarmMarkdownRouteModule(input) {
+  const { body } = parseMarkdownFrontmatter(input.source);
+  const components = input.components || {};
+  const className = _optionalChain([input, 'access', _6 => _6.config, 'optionalAccess', _7 => _7.className]) || "farm-markdown";
+  let evaluatedPromise;
+  const loadContent = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+    _nullishCoalesce(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,
+          ..._optionalChain([props, 'optionalAccess', _8 => _8.components])
+        }
+      })
+    );
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, FarmMarkdownPage, "FarmMarkdownPage");
+  return {
+    default: FarmMarkdownPage,
+    metadata: createMarkdownMetadata(input.source, input.filePath),
+    source: input.source
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmMarkdownRouteModule, "createFarmMarkdownRouteModule");
+async function createFarmMarkdownSourceResponse(options) {
+  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
+    return null;
+  }
+  if (_optionalChain([options, 'access', _9 => _9.config, 'optionalAccess', _10 => _10.markdownRoutes]) === false) {
+    return null;
+  }
+  const url = new URL(options.request.url);
+  const hasMarkdownExtension = url.pathname.toLowerCase().endsWith(".md");
+  if (!hasMarkdownExtension && !_chunkBBVSJVBZcjs.requestAcceptsMarkdown.call(void 0, options.request.headers.get("accept"))) {
+    return null;
+  }
+  const targetPathname = normalizeFarmMarkdownRoutePath(url.pathname);
+  const source = await options.resolveSource(targetPathname);
+  if (!source) {
+    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 new Response(options.request.method === "HEAD" ? null : source.source, {
+    status: 200,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmMarkdownSourceResponse, "createFarmMarkdownSourceResponse");
+
+
+
+
+
+
+
+
+
+exports.isFarmMarkdownPageFile = isFarmMarkdownPageFile; exports.normalizeFarmMarkdownRoutePath = normalizeFarmMarkdownRoutePath; exports.parseMarkdownFrontmatter = parseMarkdownFrontmatter; exports.titleFromMarkdown = titleFromMarkdown; exports.createMarkdownMetadata = createMarkdownMetadata; exports.createFarmMarkdownRouteModule = createFarmMarkdownRouteModule; exports.createFarmMarkdownSourceResponse = createFarmMarkdownSourceResponse;

package/dist/chunk-AMDMVWMI.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/font.ts
+function defineLayoutFonts(fonts) {
+  return fonts;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineLayoutFonts, "defineLayoutFonts");
+function resolveFarmLayoutFonts(layouts) {
+  let resolved;
+  for (const layout of layouts) {
+    if (!layout.fonts) continue;
+    resolved = { ...resolved, ...layout.fonts };
+  }
+  return resolved;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmLayoutFonts, "resolveFarmLayoutFonts");
+function fontCompilerError(loader) {
+  throw new Error(
+    `[Farm fonts] ${loader}() must be called at module scope with static options and compiled by the Farm Vite plugin.`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, fontCompilerError, "fontCompilerError");
+function localFont(_options) {
+  return fontCompilerError("localFont");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, localFont, "localFont");
+function remoteFont(_options) {
+  return fontCompilerError("remoteFont");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, remoteFont, "remoteFont");
+
+
+
+
+
+
+exports.defineLayoutFonts = defineLayoutFonts; exports.resolveFarmLayoutFonts = resolveFarmLayoutFonts; exports.localFont = localFont; exports.remoteFont = remoteFont;