@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-77GNHH2Z.cjs

@@ -0,0 +1,236 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkYX3DBN4Mcjs = require('./chunk-YX3DBN4M.cjs');
+
+
+
+
+
+var _chunkDVM4FKZLcjs = require('./chunk-DVM4FKZL.cjs');
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunkUXFQ3UDAcjs = require('./chunk-UXFQ3UDA.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/plugins/redirects.ts
+function createRedirectsPlugin(redirects, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  for (const redirect of redirects) {
+    if (redirect.statusCode !== void 0 && !_chunkOX6O6WVAcjs.isFarmRedirectStatus.call(void 0, 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: _chunkDVM4FKZLcjs.compileConfigRoutePattern.call(void 0, redirect.source)
+  }));
+  return {
+    name: "farm:redirects",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkUXFQ3UDAcjs.resolveFarmRequestURL.call(void 0, req);
+      const routePath = _chunkDVM4FKZLcjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n);
+      const pathname = routePath.pathname;
+      for (const { redirect, pattern } of compiledRedirects) {
+        const match = pathname.match(pattern.regex);
+        if (match) {
+          const localizedDestination = _chunkDVM4FKZLcjs.localizeConfigRouteDestination.call(void 0, 
+            _chunkDVM4FKZLcjs.interpolateConfigRouteDestination.call(void 0, redirect.destination, match, pattern.tokens),
+            routePath.locale,
+            i18n
+          );
+          const destination = _chunkYX3DBN4Mcjs.appendFarmRedirectQuery.call(void 0, localizedDestination, url.search);
+          const statusCode = _nullishCoalesce(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);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRedirectsPlugin, "createRedirectsPlugin");
+
+// 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}`);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendConfiguredLinkHeader, "appendConfiguredLinkHeader");
+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]);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendConfiguredSetCookieHeader, "appendConfiguredSetCookieHeader");
+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);
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyResponseHeaders, "applyResponseHeaders");
+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);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyWriteHeadHeaders, "applyWriteHeadHeaders");
+function createHeadersPlugin(headers, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  const compiledHeaders = headers.map((config) => ({
+    config,
+    pattern: _chunkDVM4FKZLcjs.compileConfigRoutePattern.call(void 0, config.source)
+  }));
+  return {
+    name: "farm:headers",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkUXFQ3UDAcjs.resolveFarmRequestURL.call(void 0, req);
+      const pathname = _chunkDVM4FKZLcjs.resolveConfigRoutePathname.call(void 0, 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);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createHeadersPlugin, "createHeadersPlugin");
+
+// 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);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEnvPlugin, "createEnvPlugin");
+
+// 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createLoggerPlugin, "createLoggerPlugin");
+
+
+
+
+
+
+exports.createRedirectsPlugin = createRedirectsPlugin; exports.createHeadersPlugin = createHeadersPlugin; exports.createEnvPlugin = createEnvPlugin; exports.createLoggerPlugin = createLoggerPlugin;

package/dist/chunk-7DBXEASO.cjs

@@ -0,0 +1,40 @@
+"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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunk3TLO7SBYcjs = require('./chunk-3TLO7SBY.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/app-markdown.ts
+var _promises = require('fs/promises');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
+  const source = await _promises.readFile.call(void 0, filePath, "utf8");
+  return _chunk3TLO7SBYcjs.createFarmMarkdownRouteModule.call(void 0, {
+    source,
+    filePath,
+    components: options.components,
+    config: options.config
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmMarkdownRouteModuleFromFile, "createFarmMarkdownRouteModuleFromFile");
+async function loadFarmMdxComponents(config, options) {
+  const configured = _optionalChain([config, 'optionalAccess', _ => _.components]);
+  if (!configured) {
+    return {};
+  }
+  if (typeof configured !== "string") {
+    return configured;
+  }
+  const modulePath = _path2.default.isAbsolute(configured) ? configured : _path2.default.join(options.root, configured);
+  const mod = options.loadModule ? await options.loadModule(modulePath) : await import(_url.pathToFileURL.call(void 0, modulePath).href);
+  const maybeModule = mod;
+  return maybeModule.components || maybeModule.default || {};
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmMdxComponents, "loadFarmMdxComponents");
+
+
+
+
+exports.createFarmMarkdownRouteModuleFromFile = createFarmMarkdownRouteModuleFromFile; exports.loadFarmMdxComponents = loadFarmMdxComponents;

package/dist/chunk-7LTCDQRS.mjs

@@ -0,0 +1,166 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/api/config.ts
+var DEFAULT_FARM_API_BASE_PATH = "/api";
+async function resolveFarmAPIConfig(config, context) {
+  const configuredBasePath = await resolveConfigValue(config?.basePath, context, "api.basePath");
+  const basePath = normalizeFarmAPIBasePath(configuredBasePath ?? DEFAULT_FARM_API_BASE_PATH);
+  const configuredBaseURL = await resolveConfigValue(config?.baseURL, context, "api.baseURL");
+  return normalizeFarmAPIConfig({ baseURL: configuredBaseURL, basePath });
+}
+__name(resolveFarmAPIConfig, "resolveFarmAPIConfig");
+function normalizeFarmAPIConfig(config) {
+  const basePath = normalizeFarmAPIBasePath(config?.basePath ?? DEFAULT_FARM_API_BASE_PATH);
+  const baseURL = config?.baseURL?.trim();
+  if (!baseURL) {
+    return { baseURL: basePath, basePath };
+  }
+  if (baseURL.startsWith("//")) {
+    throw new Error(
+      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api", not a network-path reference.'
+    );
+  }
+  if (baseURL.startsWith("/")) {
+    const url2 = parseRootRelativeBaseURL(baseURL);
+    if (url2.pathname !== "/") {
+      const effectivePath = normalizeFarmAPIBasePath(url2.pathname);
+      return { baseURL: effectivePath, basePath: effectivePath };
+    }
+    return { baseURL: basePath, basePath };
+  }
+  let url;
+  try {
+    url = new URL(baseURL);
+  } catch {
+    throw new Error(
+      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api".'
+    );
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Farm api.baseURL must use http or https.");
+  }
+  if (url.search || url.hash) {
+    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
+  }
+  if (url.pathname !== "/") {
+    const effectivePath = normalizeFarmAPIBasePath(url.pathname);
+    return {
+      baseURL: `${url.origin}${effectivePath}`,
+      basePath: effectivePath
+    };
+  }
+  return {
+    baseURL: basePath === "/" ? url.origin : `${url.origin}${basePath}`,
+    basePath
+  };
+}
+__name(normalizeFarmAPIConfig, "normalizeFarmAPIConfig");
+function normalizeFarmAPIBasePath(value) {
+  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  }), "hasUnstableCharacters");
+  if (hasUnstableCharacters(value)) {
+    throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
+  }
+  const path = value.trim();
+  if (!path) {
+    throw new Error("Farm api.basePath cannot be empty.");
+  }
+  if (path.includes("?") || path.includes("#")) {
+    throw new Error("Farm api.basePath cannot contain a query string or hash.");
+  }
+  if (path.startsWith("//")) {
+    throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("Farm api.basePath cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
+    }
+  }
+  const normalized = `/${path.replace(/^\/+|\/+$/g, "")}`;
+  return normalized === "/" ? "/" : normalized;
+}
+__name(normalizeFarmAPIBasePath, "normalizeFarmAPIBasePath");
+function getFarmAPIBaseURL() {
+  if (typeof __FARM_API_BASE_URL__ !== "undefined" && __FARM_API_BASE_URL__) {
+    return __FARM_API_BASE_URL__;
+  }
+  return DEFAULT_FARM_API_BASE_PATH;
+}
+__name(getFarmAPIBaseURL, "getFarmAPIBaseURL");
+function resolveFarmAPIRequestURL(routePath, baseURL = getFarmAPIBaseURL(), fallbackOrigin = getDefaultOrigin()) {
+  const base = new URL(baseURL, fallbackOrigin);
+  if (base.pathname === "/") {
+    return new URL(routePath, base);
+  }
+  const route = new URL(routePath, fallbackOrigin);
+  const suffix = stripCanonicalAPIBasePath(route.pathname);
+  const joinedPath = joinURLPath(base.pathname, suffix);
+  base.pathname = joinedPath;
+  base.search = route.search;
+  base.hash = route.hash;
+  return base;
+}
+__name(resolveFarmAPIRequestURL, "resolveFarmAPIRequestURL");
+async function resolveConfigValue(value, context, name) {
+  const resolved = typeof value === "function" ? await value(context) : value;
+  if (resolved === void 0) return void 0;
+  if (typeof resolved !== "string") {
+    throw new Error(`Farm ${name} must resolve to a string or undefined.`);
+  }
+  if (!resolved.trim()) {
+    throw new Error(`Farm ${name} cannot be empty.`);
+  }
+  return resolved;
+}
+__name(resolveConfigValue, "resolveConfigValue");
+function parseRootRelativeBaseURL(value) {
+  const url = new URL(value, "http://farm.local");
+  if (url.search || url.hash) {
+    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
+  }
+  return url;
+}
+__name(parseRootRelativeBaseURL, "parseRootRelativeBaseURL");
+function stripCanonicalAPIBasePath(pathname) {
+  if (pathname === DEFAULT_FARM_API_BASE_PATH) return "";
+  if (pathname.startsWith(`${DEFAULT_FARM_API_BASE_PATH}/`)) {
+    return pathname.slice(DEFAULT_FARM_API_BASE_PATH.length + 1);
+  }
+  return pathname.replace(/^\/+/, "");
+}
+__name(stripCanonicalAPIBasePath, "stripCanonicalAPIBasePath");
+function joinURLPath(basePath, suffix) {
+  const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/+$/, "");
+  const normalizedSuffix = suffix.replace(/^\/+/, "");
+  if (!normalizedSuffix) return normalizedBase || "/";
+  return `${normalizedBase}/${normalizedSuffix}`;
+}
+__name(joinURLPath, "joinURLPath");
+function getDefaultOrigin() {
+  return typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
+}
+__name(getDefaultOrigin, "getDefaultOrigin");
+
+export {
+  DEFAULT_FARM_API_BASE_PATH,
+  resolveFarmAPIConfig,
+  normalizeFarmAPIConfig,
+  normalizeFarmAPIBasePath,
+  getFarmAPIBaseURL,
+  resolveFarmAPIRequestURL
+};

package/dist/chunk-7W3CPVXS.cjs

@@ -0,0 +1,24 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/theme/bridge.ts
+var FALLBACK_SERVER_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: void 0,
+  mounted: false
+});
+var FARM_THEME_SERVER_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.js.theme.server-snapshot-resolver");
+function _setFarmThemeServerSnapshotResolver(resolver) {
+  globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER] = resolver;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _setFarmThemeServerSnapshotResolver, "_setFarmThemeServerSnapshotResolver");
+function getFarmThemeServerSnapshot() {
+  return _nullishCoalesce(_optionalChain([globalThis, 'access', _ => _[FARM_THEME_SERVER_SNAPSHOT_RESOLVER], 'optionalCall', _2 => _2()]), () => ( FALLBACK_SERVER_SNAPSHOT));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmThemeServerSnapshot, "getFarmThemeServerSnapshot");
+
+
+
+
+exports._setFarmThemeServerSnapshotResolver = _setFarmThemeServerSnapshotResolver; exports.getFarmThemeServerSnapshot = getFarmThemeServerSnapshot;

package/dist/chunk-A6WIQH5Z.cjs

@@ -0,0 +1,31 @@
+"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 _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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/build/production-vite.ts
+function assertRequestedProductionViteBuilder() {
+  const requested = _optionalChain([process, 'access', _ => _.env, 'access', _2 => _2.FARM_VITE_BUILDER, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4(), 'access', _5 => _5.toLowerCase, 'call', _6 => _6()]);
+  if (!requested || requested === "rolldown") return;
+  if (requested === "rollup") {
+    throw new Error(
+      "FARM_VITE_BUILDER=rollup is no longer supported: Farm builds with Vite 8, which bundles with Rolldown. Remove FARM_VITE_BUILDER."
+    );
+  }
+  throw new Error('FARM_VITE_BUILDER must be "rolldown" when set');
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertRequestedProductionViteBuilder, "assertRequestedProductionViteBuilder");
+async function loadFarmProductionVite() {
+  assertRequestedProductionViteBuilder();
+  const runtime = await import("vite");
+  return {
+    build: runtime.build,
+    createServer: runtime.createServer,
+    loadEnv: runtime.loadEnv,
+    builder: "rolldown"
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmProductionVite, "loadFarmProductionVite");
+
+
+
+exports.loadFarmProductionVite = loadFarmProductionVite;