@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-BHJAYPYU.mjs

@@ -1,387 +0,0 @@
-import {
-  findProgrammaticRouteFilesInDir
-} from "./chunk-FSXSQQTV.mjs";
-import {
-  isFarmAPIRouteFileName
-} from "./chunk-YX6AFPXC.mjs";
-import {
-  _runWithFarmI18nRequest
-} from "./chunk-CV6MFQ4Y.mjs";
-import {
-  explainMissingOptionalPeer
-} from "./chunk-NR63PD3P.mjs";
-import {
-  API_ROUTE_METHODS,
-  getAllowedAPIRouteMethods,
-  invokeAPIRouteEndpoint,
-  matchAPIRouteAtBasePath,
-  mergePluginAPIRoutes,
-  resolveAPIRouteEndpoint
-} from "./chunk-RPUJHJHE.mjs";
-import {
-  registerAPIRouteShape
-} from "./chunk-GWXZS7K5.mjs";
-import {
-  createProgrammaticRouteModuleId
-} from "./chunk-6YFC3ZFX.mjs";
-import {
-  getFarmRouteRuntimeConfig,
-  normalizeFarmRouteRuntimeConfig
-} from "./chunk-EVMXPJCB.mjs";
-import {
-  toFileModuleUrl
-} from "./chunk-VHIXGZYH.mjs";
-import {
-  loadFarmDevModule
-} from "./chunk-TUOO6IK3.mjs";
-import {
-  logger
-} from "./chunk-JSDV2NUN.mjs";
-import {
-  AmbiguousRouteError,
-  NonTerminalCatchAllRouteError
-} from "./chunk-AYP2YFVN.mjs";
-
-// src/api/route-manager.ts
-import * as fs from "fs";
-import * as path from "path";
-var APIRouteConflictError = class extends Error {
-  constructor(routePath, method, existingFile, conflictingFile) {
-    super(
-      `Duplicate API route for ${method.toUpperCase()} ${routePath}: ${existingFile} conflicts with ${conflictingFile}`
-    );
-    this.name = "APIRouteConflictError";
-  }
-};
-var APIRouteManager = class {
-  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 = options.plugins ?? [];
-    this.throwOnLoadError = options.throwOnLoadError === true;
-    this.i18n = options.i18n;
-    this.bodySizeLimit = options.bodySizeLimit;
-    this.basePath = options.basePath;
-    this.dispatch = options.dispatch;
-  }
-  /** Every file the current handlers were loaded from: route files and root routes files. */
-  getSourceFiles() {
-    const files = /* @__PURE__ */ new Set();
-    for (const sources of this.endpointSources.values()) {
-      for (const { filePath } of sources.values()) files.add(filePath);
-    }
-    return files;
-  }
-  /**
-   * 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(
-        mergePluginAPIRoutes([...this.routes.values()], this.plugins, void 0, {
-          bodySizeLimit: this.bodySizeLimit,
-          dispatch: this.dispatch
-        }).map((route) => [route.path, route])
-      );
-    } catch (error) {
-      this.routes = previousRoutes;
-      this.endpointSources = previousEndpointSources;
-      this.routeShapes = previousRouteShapes;
-      throw error;
-    }
-    if (process.env.FARM_VERBOSE) {
-      logger.success(`Discovered ${this.routes.size} API routes`);
-      for (const [routePath, route] of this.routes) {
-        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 (isFarmAPIRouteFileName(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 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 (existingSource?.appDir === appDir) {
-              throw new APIRouteConflictError(routePath, method, existingSource.filePath, filePath);
-            }
-          }
-        }
-        const runtimeConfig = normalizeFarmRouteRuntimeConfig(
-          getFarmRouteRuntimeConfig(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: { ...existingRoute?.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 (!endpoint?.__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) => findProgrammaticRouteFilesInDir(srcRoot)))
-    );
-    if (routeFiles.length === 0) return;
-    const { getProgrammaticRouteManifest } = await import("./routes.mjs");
-    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, loadError) {
-    const error = explainMissingOptionalPeer(loadError, message.replace(/^Error loading /, ""));
-    logger.error(`${message}: ${error}`);
-    if (this.throwOnLoadError || error instanceof APIRouteConflictError || error instanceof AmbiguousRouteError || error instanceof 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 loadFarmDevModule(this.viteServer, filePath);
-    }
-    return await import(
-      /* @vite-ignore */
-      toFileModuleUrl(filePath)
-    );
-  }
-  addEndpoint(routePath, filePath, method, endpoint, appDir, runtimeConfig = {}) {
-    const normalizedMethod = method.toUpperCase();
-    const existingRoute = this.routes.get(routePath);
-    const existingSource = this.endpointSources.get(routePath)?.get(normalizedMethod);
-    if (existingSource?.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 = 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 = createProgrammaticRouteModuleId(filePath, "api", route.path);
-    const runtimeConfig = normalizeFarmRouteRuntimeConfig(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 = registerAPIRouteShape(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 = matchAPIRouteAtBasePath(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 = resolveAPIRouteEndpoint(route, method);
-      if (!endpoint) {
-        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
-          status: 405,
-          headers: {
-            Allow: getAllowedAPIRouteMethods(route).join(", "),
-            "Content-Type": "application/json"
-          }
-        });
-      }
-      const invoke = async () => {
-        try {
-          return await invokeAPIRouteEndpoint(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" }
-          });
-        }
-      };
-      return this.i18n?.config.enabled ? _runWithFarmI18nRequest(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 matchAPIRouteAtBasePath(this.routes, pathname, this.basePath);
-  }
-  /**
-   * Get all routes for client type generation
-   */
-  getRoutes() {
-    return this.routes;
-  }
-};
-
-export {
-  APIRouteConflictError,
-  APIRouteManager
-};

package/dist/chunk-BMQAPZXD.mjs

@@ -1,31 +0,0 @@
-// src/route-context.ts
-var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
-async function resolveFarmRouteContext(config, input) {
-  if (typeof config.context !== "function") {
-    return void 0;
-  }
-  return config.context(input);
-}
-function withFarmRouteContext(props, context) {
-  if (context === void 0) {
-    return props;
-  }
-  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
-    value: context,
-    enumerable: false,
-    configurable: true
-  });
-  return props;
-}
-function getFarmRouteContext(props) {
-  if (!props || typeof props !== "object") {
-    return void 0;
-  }
-  return props[FARM_ROUTE_CONTEXT_SYMBOL];
-}
-
-export {
-  resolveFarmRouteContext,
-  withFarmRouteContext,
-  getFarmRouteContext
-};

package/dist/chunk-BNH53KOT.cjs

@@ -1,69 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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/api/dev-dispatch.ts
-var _http = require('http'); var _http2 = _interopRequireDefault(_http);
-var _https = require('https'); var _https2 = _interopRequireDefault(_https);
-var _stream = require('stream');
-function createFarmDevServerDispatch(server) {
-  return (request) => new Promise((resolve, reject) => {
-    const address = _optionalChain([server, 'access', _ => _.httpServer, 'optionalAccess', _2 => _2.address, 'call', _3 => _3()]);
-    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 ? _https2.default : _http2.default).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 = _nullishCoalesce(incoming.statusCode, () => ( 502));
-        const hasBody = request.method !== "HEAD" && status !== 204 && status !== 205 && status !== 304;
-        if (!hasBody) incoming.resume();
-        try {
-          resolve(
-            new Response(
-              hasBody ? _stream.Readable.toWeb(incoming) : null,
-              { status, statusText: incoming.statusMessage, headers: responseHeaders }
-            )
-          );
-        } catch (error) {
-          incoming.destroy();
-          reject(error);
-        }
-      }
-    );
-    outgoing.on("error", reject);
-    if (request.body) {
-      _stream.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;
-}
-
-
-
-exports.createFarmDevServerDispatch = createFarmDevServerDispatch;

package/dist/chunk-BPAXGCKX.mjs

@@ -1,166 +0,0 @@
-import {
-  matchSegmentParts,
-  normalizePathname,
-  normalizeRoutePattern,
-  parseRoutePattern,
-  splitNormalizedPathname,
-  splitPathname
-} from "./chunk-MFQGU5CC.mjs";
-import {
-  AmbiguousRouteError,
-  compareRouteSpecificity,
-  getRoutePatternShape
-} from "./chunk-AYP2YFVN.mjs";
-
-// src/router.ts
-function createFarmRouter(routes) {
-  const normalizedRoutes = routes.map(normalizeRouteInput);
-  const patternsByShape = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    const shape = getRoutePatternShape(entry.route.path, "router");
-    const existingPattern = patternsByShape.get(shape);
-    if (existingPattern) {
-      throw new AmbiguousRouteError(
-        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
-      );
-    }
-    patternsByShape.set(shape, entry.route.path);
-  }
-  normalizedRoutes.sort(compareRoutes);
-  const exactRoutes = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    if (entry.segments.every((segment) => segment.type === "static")) {
-      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
-      exactRoutes.set(pathname, entry);
-    }
-  }
-  return {
-    routes: normalizedRoutes.map((entry) => entry.route),
-    match(pathname) {
-      const normalizedPathname = normalizePathname(pathname);
-      const exactRoute = exactRoutes.get(normalizedPathname);
-      if (exactRoute) {
-        return {
-          route: exactRoute.route,
-          pathname: normalizedPathname,
-          params: {}
-        };
-      }
-      const parts = splitNormalizedPathname(normalizedPathname);
-      for (const entry of normalizedRoutes) {
-        const params = matchSegmentParts(entry.segments, parts);
-        if (params) {
-          return {
-            route: entry.route,
-            pathname: normalizedPathname,
-            params
-          };
-        }
-      }
-      return null;
-    },
-    build: buildFarmRoutePath,
-    isActive: isFarmRouteActive
-  };
-}
-function matchFarmRoute(pattern, pathname) {
-  return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));
-}
-function buildFarmRoutePath(pattern, params = {}, options = {}) {
-  const parts = [];
-  for (const segment of parseRoutePattern(pattern)) {
-    if (segment.type === "static") {
-      parts.push(encodePathSegment(segment.value));
-      continue;
-    }
-    const value = params[segment.name];
-    const values = Array.isArray(value) ? value : value == null ? [] : [value];
-    if (values.length === 0) {
-      if (segment.optional) continue;
-      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
-    }
-    if (!segment.catchAll && values.length > 1) {
-      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
-    }
-    const encodedValues = values.map((item) => {
-      const value2 = String(item);
-      if (!value2) {
-        throw new Error(
-          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
-        );
-      }
-      return encodePathSegment(value2);
-    });
-    parts.push(...encodedValues);
-  }
-  let pathname = parts.length ? `/${parts.join("/")}` : "/";
-  if (options.trailingSlash && pathname !== "/") {
-    pathname = `${pathname}/`;
-  }
-  return appendQueryAndHash(pathname, options);
-}
-function isFarmRouteActive(pattern, pathname, options = {}) {
-  const normalizedPathname = normalizePathname(pathname);
-  const segments = parseRoutePattern(pattern);
-  const parts = splitNormalizedPathname(normalizedPathname);
-  if (matchSegmentParts(segments, parts)) return true;
-  if (options.exact !== false) return false;
-  if (segments.length === 0) return normalizedPathname === "/";
-  return matchSegmentParts(segments, parts, true) !== null;
-}
-function normalizeRouteInput(input, index) {
-  const route = typeof input === "string" ? { path: input } : input;
-  const segments = parseRoutePattern(route.path);
-  const path = normalizeRoutePattern(route.path);
-  return {
-    route: {
-      ...route,
-      path
-    },
-    segments,
-    specificity: segments.map(getRouterSegmentSpecificity),
-    index
-  };
-}
-function matchSegments(segments, pathname, allowTrailingSegments = false) {
-  return matchSegmentParts(segments, splitPathname(pathname), allowTrailingSegments);
-}
-function compareRoutes(left, right) {
-  const specificity = compareRouteSpecificity(left.specificity, right.specificity);
-  if (specificity !== 0) return specificity;
-  return left.index - right.index;
-}
-function getRouterSegmentSpecificity(segment) {
-  if (segment.type === "static") return "static";
-  if (!segment.catchAll) return "dynamic";
-  return segment.optional ? "optional-catch-all" : "catch-all";
-}
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-function appendQueryAndHash(pathname, options) {
-  const search = createSearchParams(options.query);
-  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
-  const query = search.toString();
-  return `${pathname}${query ? `?${query}` : ""}${hash}`;
-}
-function createSearchParams(query) {
-  if (query instanceof URLSearchParams) return query;
-  const search = new URLSearchParams();
-  if (!query) return search;
-  for (const [key, value] of Object.entries(query)) {
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item == null) continue;
-      search.append(key, String(item));
-    }
-  }
-  return search;
-}
-
-export {
-  createFarmRouter,
-  matchFarmRoute,
-  buildFarmRoutePath,
-  isFarmRouteActive
-};