@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-6MVFL3R5.cjs

@@ -0,0 +1,506 @@
+"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 _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/dev-indicators.ts
+function resolveFarmDevIndicatorsConfig(config, mode = "development") {
+  return {
+    buildActivity: mode === "development" && (_nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.buildActivity]), () => ( true))),
+    buildActivityPosition: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.buildActivityPosition]), () => ( "bottom-right"))
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmDevIndicatorsConfig, "resolveFarmDevIndicatorsConfig");
+function generateFarmDevIndicatorsClientRuntime(config) {
+  if (!config.buildActivity) return "";
+  const position = {
+    "bottom-right": "right: 16px; bottom: 16px;",
+    "bottom-left": "left: 16px; bottom: 16px;",
+    "top-right": "right: 16px; top: 16px;",
+    "top-left": "left: 16px; top: 16px;"
+  }[config.buildActivityPosition];
+  const styles = `
+    #__farm_build_activity__ {
+      position: fixed;
+      ${position}
+      z-index: 2147483645;
+      display: inline-flex;
+      align-items: center;
+      min-height: 34px;
+      padding: 0 11px;
+      border: 1px solid rgb(255 255 255 / 0.16);
+      border-radius: 6px;
+      background: rgb(8 8 8 / 0.94);
+      box-shadow: 0 8px 24px rgb(0 0 0 / 0.2);
+      color: rgb(250 250 250);
+      font: 500 10px/1 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      letter-spacing: 0;
+      opacity: 0;
+      pointer-events: none;
+      transform: translateY(4px);
+      transition: opacity 120ms ease-out, transform 120ms ease-out;
+      -webkit-backdrop-filter: blur(12px);
+      backdrop-filter: blur(12px);
+    }
+    #__farm_build_activity__[data-visible="true"] {
+      opacity: 1;
+      transform: translateY(0);
+    }
+    .farm-build-activity__brand {
+      display: inline-flex;
+      align-items: center;
+      gap: 7px;
+      flex: none;
+    }
+    .farm-build-activity__mark {
+      width: 17px;
+      height: 16px;
+      flex: none;
+    }
+    .farm-build-activity__wordmark {
+      color: rgb(255 255 255);
+      font-size: 11px;
+      font-weight: 400;
+      line-height: 1;
+    }
+    .farm-build-activity__wordmark-suffix { color: rgb(255 255 255 / 0.52); }
+    .farm-build-activity__divider {
+      width: 1px;
+      height: 14px;
+      margin: 0 9px;
+      flex: none;
+      background: rgb(255 255 255 / 0.14);
+    }
+    .farm-build-activity__loader {
+      display: grid;
+      width: 15px;
+      grid-template-columns: repeat(3, 4px);
+      gap: 1.5px;
+      flex: none;
+    }
+    .farm-build-activity__cell {
+      width: 4px;
+      height: 4px;
+      border-radius: 1px;
+      background: currentColor;
+      opacity: 0.15;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell {
+      animation: farm-build-activity-pixel-on 650ms ease-in-out infinite;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(1),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(7) {
+      animation-delay: 90ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(2),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(6),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(8) {
+      animation-delay: 180ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(9) {
+      animation-delay: 270ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(4) {
+      animation-delay: 0ms;
+    }
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell,
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell {
+      opacity: 0.08;
+    }
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(6),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(7),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(8),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(1),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(7),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(9) {
+      opacity: 1;
+    }
+    .farm-build-activity__label {
+      margin-left: 7px;
+      color: rgb(255 255 255 / 0.62);
+      font-size: 9px;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      white-space: nowrap;
+    }
+    .farm-build-activity__sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border: 0;
+    }
+    #__farm_build_activity__[data-state="error"] {
+      border-color: rgb(248 113 113 / 0.55);
+    }
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__loader,
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__label {
+      color: rgb(254 202 202);
+    }
+    @keyframes farm-build-activity-pixel-on {
+      0%, 32%, 100% { opacity: 0.15; }
+      14% { opacity: 1; }
+    }
+    @media (prefers-reduced-motion: reduce) {
+      #__farm_build_activity__ { transition: none; }
+      #__farm_build_activity__[data-state="building"] .farm-build-activity__cell {
+        animation: none;
+        opacity: 0.28;
+      }
+    }
+  `;
+  return `
+if (import.meta.hot) {
+  (() => {
+    const hot = import.meta.hot;
+    const indicatorId = "__farm_build_activity__";
+    const styleId = "__farm_build_activity_styles__";
+    const runtimeKey = "__FARM_BUILD_ACTIVITY_RUNTIME__";
+    const reloadMarker = "__FARM_BUILD_ACTIVITY_RELOADING__";
+    let hideTimer;
+
+    const createBrandMark = () => {
+      const namespace = "http://www.w3.org/2000/svg";
+      const mark = document.createElementNS(namespace, "svg");
+      mark.setAttribute("class", "farm-build-activity__mark");
+      mark.setAttribute("viewBox", "125 68 161 152");
+      mark.setAttribute("fill", "none");
+      mark.setAttribute("aria-hidden", "true");
+
+      const shapes = [
+        ["M157 68H133C128.582 68 125 71.5817 125 76V100C125 104.418 128.582 108 133 108H157C161.418 108 165 104.418 165 100V76C165 71.5817 161.418 68 157 68Z", "#F5F5F4"],
+        ["M182.383 68H280.617C282.045 68 283.414 68.8429 284.423 70.3431C285.433 71.8434 286 73.8783 286 76V100C286 102.122 285.433 104.157 284.423 105.657C283.414 107.157 282.045 108 280.617 108H182.383C180.955 108 179.586 107.157 178.577 105.657C177.567 104.157 177 102.122 177 100V76C177 73.8783 177.567 71.8434 178.577 70.3431C179.586 68.8429 180.955 68 182.383 68ZM271.852 81C270.747 81 269.852 81.8954 269.852 83V93C269.852 94.1046 270.747 95 271.852 95H277.272C278.376 95 279.272 94.1046 279.272 93V83C279.272 81.8954 278.376 81 277.272 81H271.852Z", "#F5F5F4"],
+        ["M157 124H133C128.582 124 125 127.582 125 132V156C125 160.418 128.582 164 133 164H157C161.418 164 165 160.418 165 156V132C165 127.582 161.418 124 157 124Z", "#A3A3A3"],
+        ["M280.334 124H182.666C179.537 124 177 127.582 177 132V156C177 160.418 179.537 164 182.666 164H280.334C283.463 164 286 160.418 286 156V132C286 127.582 283.463 124 280.334 124Z", "#A3A3A3"],
+        ["M157 180H133C128.582 180 125 183.582 125 188V212C125 216.418 128.582 220 133 220H157C161.418 220 165 216.418 165 212V188C165 183.582 161.418 180 157 180Z", "#595959"],
+        ["M230.189 180H182.811C179.602 180 177 183.582 177 188V212C177 216.418 179.602 220 182.811 220H230.189C233.398 220 236 216.418 236 212V188C236 183.582 233.398 180 230.189 180Z", "#595959"],
+      ];
+      for (const [index, [pathData, fill]] of shapes.entries()) {
+        const path = document.createElementNS(namespace, "path");
+        path.setAttribute("d", pathData);
+        path.setAttribute("fill", fill);
+        if (index === 1) {
+          path.setAttribute("fill-rule", "evenodd");
+          path.setAttribute("clip-rule", "evenodd");
+        }
+        mark.appendChild(path);
+      }
+      return mark;
+    };
+
+    const ensureIndicator = () => {
+      let style = document.getElementById(styleId);
+      if (!style) {
+        style = document.createElement("style");
+        style.id = styleId;
+        style.textContent = ${JSON.stringify(styles)};
+        document.head.appendChild(style);
+      }
+
+      let indicator = document.getElementById(indicatorId);
+      if (!indicator) {
+        indicator = document.createElement("div");
+        indicator.id = indicatorId;
+        indicator.setAttribute("role", "status");
+        indicator.setAttribute("aria-live", "polite");
+
+        const brand = document.createElement("span");
+        brand.className = "farm-build-activity__brand";
+        brand.setAttribute("aria-hidden", "true");
+        const wordmark = document.createElement("span");
+        wordmark.className = "farm-build-activity__wordmark";
+        const suffix = document.createElement("span");
+        suffix.className = "farm-build-activity__wordmark-suffix";
+        suffix.textContent = ".JS";
+        wordmark.append("FARM", suffix);
+        brand.append(createBrandMark(), wordmark);
+
+        const divider = document.createElement("span");
+        divider.className = "farm-build-activity__divider";
+        divider.setAttribute("aria-hidden", "true");
+
+        const loader = document.createElement("span");
+        loader.className = "farm-build-activity__loader";
+        loader.setAttribute("aria-hidden", "true");
+        for (let index = 0; index < 9; index += 1) {
+          const cell = document.createElement("span");
+          cell.className = "farm-build-activity__cell";
+          loader.appendChild(cell);
+        }
+
+        const label = document.createElement("span");
+        label.className = "farm-build-activity__label";
+        label.setAttribute("aria-hidden", "true");
+        label.dataset.farmBuildLabel = "";
+        const message = document.createElement("span");
+        message.className = "farm-build-activity__sr-only";
+        message.dataset.farmBuildMessage = "";
+        indicator.append(loader, label, divider, brand, message);
+        document.body.appendChild(indicator);
+      }
+      return indicator;
+    };
+
+    const show = (state, label, message) => {
+      window.clearTimeout(hideTimer);
+      const indicator = ensureIndicator();
+      indicator.dataset.state = state;
+      indicator.dataset.visible = "true";
+      indicator.querySelector("[data-farm-build-label]").textContent = label;
+      indicator.querySelector("[data-farm-build-message]").textContent = message;
+    };
+    const hide = () => {
+      const indicator = document.getElementById(indicatorId);
+      if (indicator) indicator.dataset.visible = "false";
+    };
+    const onBeforeUpdate = () => show("building", "Updating", "Farm.js updating");
+    const onAfterUpdate = () => {
+      show("ready", "Ready", "Farm.js ready");
+      hideTimer = window.setTimeout(hide, 500);
+    };
+    const onError = () => show("error", "Build failed", "Farm.js build failed");
+    const onBeforeFullReload = () => {
+      try {
+        window.sessionStorage.setItem(reloadMarker, "1");
+      } catch {}
+      show("building", "Updating", "Farm.js updating");
+    };
+
+    window[runtimeKey]?.dispose?.();
+    ensureIndicator();
+    let completedReload = false;
+    try {
+      completedReload = window.sessionStorage.getItem(reloadMarker) === "1";
+      window.sessionStorage.removeItem(reloadMarker);
+    } catch {}
+    if (completedReload) onAfterUpdate();
+    else hide();
+    hot.on("vite:beforeUpdate", onBeforeUpdate);
+    hot.on("vite:afterUpdate", onAfterUpdate);
+    hot.on("vite:error", onError);
+    hot.on("vite:beforeFullReload", onBeforeFullReload);
+    window[runtimeKey] = {
+      dispose() {
+        window.clearTimeout(hideTimer);
+        hot.off("vite:beforeUpdate", onBeforeUpdate);
+        hot.off("vite:afterUpdate", onAfterUpdate);
+        hot.off("vite:error", onError);
+        hot.off("vite:beforeFullReload", onBeforeFullReload);
+        document.getElementById(indicatorId)?.remove();
+      },
+    };
+  })();
+}
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, generateFarmDevIndicatorsClientRuntime, "generateFarmDevIndicatorsClientRuntime");
+
+// src/plugin-dependencies.ts
+function pluginShortName(name) {
+  return name.slice(Math.max(name.lastIndexOf(":"), name.lastIndexOf("/")) + 1);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, pluginShortName, "pluginShortName");
+function assertPluginDependencies(plugins, integrations) {
+  const integrationKeys = integrations && !Array.isArray(integrations) ? Object.keys(integrations) : [];
+  const matches = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (plugin, dependency) => plugin.name === dependency || pluginShortName(plugin.name) === dependency, "matches");
+  for (const plugin of plugins) {
+    if (plugin.dependsOn === void 0) continue;
+    if (!Array.isArray(plugin.dependsOn) || plugin.dependsOn.some((entry) => typeof entry !== "string" || entry.trim() === "")) {
+      throw new TypeError(
+        `Plugin "${plugin.name}" has an invalid \`dependsOn\`: list plugin names, such as ["teams"].`
+      );
+    }
+    for (const dependency of plugin.dependsOn) {
+      if (matches(plugin, dependency)) {
+        throw new Error(`Plugin "${plugin.name}" lists itself in \`dependsOn\`.`);
+      }
+      const found = plugins.some((candidate) => candidate !== plugin && matches(candidate, dependency)) || integrationKeys.includes(dependency);
+      if (!found) {
+        const configured = [
+          ...plugins.map((candidate) => candidate.name),
+          ...integrationKeys
+        ].filter((name) => name !== plugin.name);
+        throw new Error(
+          `Plugin "${plugin.name}" depends on "${dependency}", which is not configured. Add it to \`plugins\` (or \`integrations\`) in farm.config.${configured.length > 0 ? ` Configured: ${configured.join(", ")}.` : ""}`
+        );
+      }
+    }
+  }
+  const state = /* @__PURE__ */ new Map();
+  const path3 = [];
+  const visit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (plugin) => {
+    if (state.get(plugin) === "done") return;
+    if (state.get(plugin) === "visiting") {
+      const cycle = [...path3.slice(path3.indexOf(plugin)), plugin].map(
+        (entry) => pluginShortName(entry.name)
+      );
+      throw new Error(`Plugins depend on each other in a cycle: ${cycle.join(" \u2192 ")}.`);
+    }
+    state.set(plugin, "visiting");
+    path3.push(plugin);
+    for (const dependency of _nullishCoalesce(plugin.dependsOn, () => ( []))) {
+      for (const candidate of plugins) {
+        if (candidate !== plugin && matches(candidate, dependency)) visit(candidate);
+      }
+    }
+    path3.pop();
+    state.set(plugin, "done");
+  }, "visit");
+  for (const plugin of plugins) visit(plugin);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertPluginDependencies, "assertPluginDependencies");
+
+// src/utils/source-dir.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var FARM_PROJECT_SOURCE_DIRS = /* @__PURE__ */ Symbol.for("farm.projectSourceDirs");
+function getProjectSourceDirs() {
+  const globalState = globalThis;
+  return _nullishCoalesce(globalState[FARM_PROJECT_SOURCE_DIRS], () => ( (globalState[FARM_PROJECT_SOURCE_DIRS] = /* @__PURE__ */ new Map())));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getProjectSourceDirs, "getProjectSourceDirs");
+function setFarmProjectSourceDir(root, srcDir) {
+  getProjectSourceDirs().set(_path2.default.resolve(root), srcDir);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setFarmProjectSourceDir, "setFarmProjectSourceDir");
+function getFarmProjectSourceDir(root) {
+  return _nullishCoalesce(getProjectSourceDirs().get(_path2.default.resolve(root)), () => ( "src"));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmProjectSourceDir, "getFarmProjectSourceDir");
+
+// src/auth-config.ts
+var _module = require('module');
+
+var _url = require('url');
+function resolveFarmAuthConfig(input) {
+  const config = input === true ? {} : input && typeof input === "object" ? input : {};
+  const passwordConfig = typeof config.emailAndPassword === "object" ? config.emailAndPassword : {};
+  const resolved = {
+    enabled: input !== void 0 && input !== false && config.enabled !== false,
+    appName: config.appName,
+    basePath: normalizeBasePath(config.basePath),
+    emailAndPassword: {
+      enabled: config.emailAndPassword !== false,
+      requireEmailVerification: _nullishCoalesce(passwordConfig.requireEmailVerification, () => ( false)),
+      minPasswordLength: _nullishCoalesce(passwordConfig.minPasswordLength, () => ( 8)),
+      maxPasswordLength: _nullishCoalesce(passwordConfig.maxPasswordLength, () => ( 128))
+    },
+    session: {
+      expiresIn: _nullishCoalesce(_optionalChain([config, 'access', _3 => _3.session, 'optionalAccess', _4 => _4.expiresIn]), () => ( 60 * 60 * 24 * 7)),
+      updateAge: _nullishCoalesce(_optionalChain([config, 'access', _5 => _5.session, 'optionalAccess', _6 => _6.updateAge]), () => ( 60 * 60 * 24))
+    },
+    database: {
+      url: _optionalChain([config, 'access', _7 => _7.database, 'optionalAccess', _8 => _8.url]),
+      path: _optionalChain([config, 'access', _9 => _9.database, 'optionalAccess', _10 => _10.path]) || ".farm/auth.sqlite",
+      migrateInDevelopment: _nullishCoalesce(_optionalChain([config, 'access', _11 => _11.database, 'optionalAccess', _12 => _12.migrateInDevelopment]), () => ( true))
+    }
+  };
+  validateFarmAuthConfig(resolved);
+  return resolved;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmAuthConfig, "resolveFarmAuthConfig");
+async function resolveFarmAuthIntegration(config, options) {
+  if (!config.enabled) return void 0;
+  const root = _path2.default.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = _module.createRequire.call(void 0, _path2.default.join(root, "package.json"));
+    modulePath = resolveFromApp.resolve("@farm.js/auth/internal");
+  } catch (e) {
+    throw new Error(
+      "The `auth` config requires @farm.js/auth. Install it with `pnpm add @farm.js/auth` and try again."
+    );
+  }
+  const runtime = await import(
+    /* @vite-ignore */
+    _url.pathToFileURL.call(void 0, modulePath).href
+  );
+  if (typeof runtime.createFarmAuthIntegration !== "function") {
+    throw new Error(
+      "The installed @farm.js/auth package is incompatible with this version of @farm.js/core."
+    );
+  }
+  return runtime.createFarmAuthIntegration(config, {
+    ...options,
+    root
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmAuthIntegration, "resolveFarmAuthIntegration");
+function normalizeBasePath(value) {
+  const route = (value || "/api/auth").trim();
+  if (!route) return "/api/auth";
+  assertStableBasePath(route);
+  const withLeadingSlash = route.startsWith("/") ? route : `/${route}`;
+  const normalized = withLeadingSlash.replace(/\/+/g, "/").replace(/\/+$/, "");
+  return normalized || "/api/auth";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeBasePath, "normalizeBasePath");
+function assertStableBasePath(route) {
+  if (route.includes("?") || route.includes("#")) {
+    throw new Error("auth.basePath cannot contain a query string or fragment.");
+  }
+  if (route.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(route)) {
+    throw new Error('auth.basePath must be an application pathname such as "/api/auth".');
+  }
+  if (hasUnstablePathCharacters(route)) {
+    throw new Error("auth.basePath cannot contain backslashes or control characters.");
+  }
+  for (const segment of route.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e2) {
+    }
+    if (hasUnstablePathCharacters(decoded) || decoded.includes("/")) {
+      throw new Error("auth.basePath cannot contain encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('auth.basePath cannot contain "." or ".." path segments.');
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertStableBasePath, "assertStableBasePath");
+function hasUnstablePathCharacters(value) {
+  return value.includes("\\") || Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasUnstablePathCharacters, "hasUnstablePathCharacters");
+function validateFarmAuthConfig(config) {
+  const { minPasswordLength, maxPasswordLength } = config.emailAndPassword;
+  if (!Number.isInteger(minPasswordLength) || minPasswordLength < 1) {
+    throw new Error("auth.emailAndPassword.minPasswordLength must be a positive integer.");
+  }
+  if (!Number.isInteger(maxPasswordLength) || maxPasswordLength < minPasswordLength) {
+    throw new Error(
+      "auth.emailAndPassword.maxPasswordLength must be an integer greater than or equal to minPasswordLength."
+    );
+  }
+  if (!Number.isInteger(config.session.expiresIn) || config.session.expiresIn < 1) {
+    throw new Error("auth.session.expiresIn must be a positive integer.");
+  }
+  if (!Number.isInteger(config.session.updateAge) || config.session.updateAge < 0) {
+    throw new Error("auth.session.updateAge must be a non-negative integer.");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateFarmAuthConfig, "validateFarmAuthConfig");
+
+
+
+
+
+
+
+
+
+
+exports.setFarmProjectSourceDir = setFarmProjectSourceDir; exports.getFarmProjectSourceDir = getFarmProjectSourceDir; exports.resolveFarmDevIndicatorsConfig = resolveFarmDevIndicatorsConfig; exports.generateFarmDevIndicatorsClientRuntime = generateFarmDevIndicatorsClientRuntime; exports.resolveFarmAuthConfig = resolveFarmAuthConfig; exports.resolveFarmAuthIntegration = resolveFarmAuthIntegration; exports.pluginShortName = pluginShortName; exports.assertPluginDependencies = assertPluginDependencies;

package/dist/chunk-6NT6S2VQ.mjs

@@ -0,0 +1,180 @@
+import {
+  matchSegmentParts,
+  normalizePathname,
+  normalizeRoutePattern,
+  parseRoutePattern,
+  splitNormalizedPathname,
+  splitPathname
+} from "./chunk-OT6ZEW74.mjs";
+import {
+  AmbiguousRouteError,
+  compareRouteSpecificity,
+  getRoutePatternShape
+} from "./chunk-55YI3RRB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.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
+  };
+}
+__name(createFarmRouter, "createFarmRouter");
+function matchFarmRoute(pattern, pathname) {
+  return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));
+}
+__name(matchFarmRoute, "matchFarmRoute");
+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);
+}
+__name(buildFarmRoutePath, "buildFarmRoutePath");
+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;
+}
+__name(isFarmRouteActive, "isFarmRouteActive");
+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
+  };
+}
+__name(normalizeRouteInput, "normalizeRouteInput");
+function matchSegments(segments, pathname, allowTrailingSegments = false) {
+  return matchSegmentParts(segments, splitPathname(pathname), allowTrailingSegments);
+}
+__name(matchSegments, "matchSegments");
+function compareRoutes(left, right) {
+  const specificity = compareRouteSpecificity(left.specificity, right.specificity);
+  if (specificity !== 0) return specificity;
+  return left.index - right.index;
+}
+__name(compareRoutes, "compareRoutes");
+function getRouterSegmentSpecificity(segment) {
+  if (segment.type === "static") return "static";
+  if (!segment.catchAll) return "dynamic";
+  return segment.optional ? "optional-catch-all" : "catch-all";
+}
+__name(getRouterSegmentSpecificity, "getRouterSegmentSpecificity");
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+__name(encodePathSegment, "encodePathSegment");
+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}`;
+}
+__name(appendQueryAndHash, "appendQueryAndHash");
+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;
+}
+__name(createSearchParams, "createSearchParams");
+
+export {
+  createFarmRouter,
+  matchFarmRoute,
+  buildFarmRoutePath,
+  isFarmRouteActive
+};