@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/navigation.cjs

@@ -0,0 +1,1329 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/navigation.ts
+var navigation_exports = {};
+__export(navigation_exports, {
+  getFarmRedirectError: () => getFarmRedirectError,
+  isFarmNotFoundError: () => isFarmNotFoundError,
+  isFarmRedirectError: () => isFarmRedirectError,
+  notFound: () => notFound,
+  permanentRedirect: () => permanentRedirect,
+  redirect: () => redirect,
+  usePathname: () => usePathname,
+  useRouter: () => useRouter2,
+  useSearchParams: () => useSearchParams
+});
+module.exports = __toCommonJS(navigation_exports);
+
+// src/client/router.ts
+var import_react = require("react");
+
+// src/router.ts
+function createFarmRouter(routes) {
+  const normalizedRoutes = routes.map(normalizeRouteInput).sort(compareRoutes);
+  return {
+    routes: normalizedRoutes.map((entry) => entry.route),
+    match(pathname) {
+      const normalizedPathname = normalizePathname(pathname);
+      for (const entry of normalizedRoutes) {
+        const params = matchSegments(entry.segments, normalizedPathname);
+        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.`);
+    }
+    parts.push(...values.map((item) => encodePathSegment(String(item))));
+  }
+  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);
+  if (matchFarmRoute(pattern, normalizedPathname)) return true;
+  if (options.exact !== false) return false;
+  const normalizedPattern = normalizePathname(pattern);
+  if (normalizedPattern === "/") return normalizedPathname === "/";
+  return normalizedPathname.startsWith(`${normalizedPattern}/`);
+}
+__name(isFarmRouteActive, "isFarmRouteActive");
+function normalizeRouteInput(input, index) {
+  const route = typeof input === "string" ? { path: input } : input;
+  const path = normalizePathname(route.path);
+  const segments = parseRoutePattern(path);
+  return {
+    route: {
+      ...route,
+      path
+    },
+    segments,
+    score: scoreSegments(segments),
+    index
+  };
+}
+__name(normalizeRouteInput, "normalizeRouteInput");
+function parseRoutePattern(pattern) {
+  return splitPathname(pattern).filter((part) => !isRouteGroup(part)).map((part) => {
+    const optionalCatchAll = part.match(/^\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]$/);
+    if (optionalCatchAll) {
+      return {
+        type: "dynamic",
+        name: optionalCatchAll[1],
+        catchAll: true,
+        optional: true
+      };
+    }
+    const catchAll = part.match(/^\[\.\.\.([A-Za-z0-9_$-]+)\]$/);
+    if (catchAll) {
+      return {
+        type: "dynamic",
+        name: catchAll[1],
+        catchAll: true,
+        optional: false
+      };
+    }
+    const dynamic = part.match(/^\[([A-Za-z0-9_$-]+)\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);
+    if (dynamic) {
+      return {
+        type: "dynamic",
+        name: dynamic[1],
+        catchAll: false,
+        optional: false
+      };
+    }
+    const star = part.match(/^\*([A-Za-z0-9_$-]+)(\?)?$/);
+    if (star) {
+      return {
+        type: "dynamic",
+        name: star[1],
+        catchAll: true,
+        optional: !!star[2]
+      };
+    }
+    return {
+      type: "static",
+      value: decodePathSegment(part)
+    };
+  });
+}
+__name(parseRoutePattern, "parseRoutePattern");
+function matchSegments(segments, pathname) {
+  const parts = splitPathname(pathname);
+  const params = {};
+  if (segments.length === 0) {
+    return parts.length === 0 ? params : null;
+  }
+  let pathIndex = 0;
+  for (const segment of segments) {
+    if (segment.type === "static") {
+      if (decodePathSegment(parts[pathIndex] || "") !== segment.value) return null;
+      pathIndex++;
+      continue;
+    }
+    if (segment.catchAll) {
+      const remaining = parts.slice(pathIndex).map(decodePathSegment);
+      if (remaining.length === 0 && !segment.optional) return null;
+      params[segment.name] = remaining.join("/");
+      pathIndex = parts.length;
+      continue;
+    }
+    const value = parts[pathIndex];
+    if (!value) return null;
+    params[segment.name] = decodePathSegment(value);
+    pathIndex++;
+  }
+  return pathIndex === parts.length ? params : null;
+}
+__name(matchSegments, "matchSegments");
+function compareRoutes(left, right) {
+  if (right.score !== left.score) return right.score - left.score;
+  return left.index - right.index;
+}
+__name(compareRoutes, "compareRoutes");
+function scoreSegments(segments) {
+  return segments.reduce((score, segment) => {
+    if (segment.type === "static") return score + 100;
+    if (!segment.catchAll) return score + 50;
+    return score + (segment.optional ? 5 : 10);
+  }, segments.length);
+}
+__name(scoreSegments, "scoreSegments");
+function normalizePathname(value) {
+  const raw = value || "/";
+  let pathname = raw;
+  try {
+    pathname = new URL(raw, "http://farm.local").pathname;
+  } catch {
+    pathname = raw.split(/[?#]/, 1)[0] || "/";
+  }
+  pathname = pathname.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
+  return pathname || "/";
+}
+__name(normalizePathname, "normalizePathname");
+function splitPathname(pathname) {
+  return normalizePathname(pathname).split("/").filter(Boolean);
+}
+__name(splitPathname, "splitPathname");
+function isRouteGroup(part) {
+  return part.startsWith("(") && part.endsWith(")");
+}
+__name(isRouteGroup, "isRouteGroup");
+function decodePathSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+__name(decodePathSegment, "decodePathSegment");
+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");
+
+// src/deferred.ts
+var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+var FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+var FARM_DEFERRED_MARKER = "$farmDeferred";
+var _DeferredDataError = class _DeferredDataError extends Error {
+  constructor(message = "Deferred route data failed to load") {
+    super(message);
+    this.name = "DeferredDataError";
+    this.code = FARM_DEFERRED_ERROR_CODE;
+  }
+};
+__name(_DeferredDataError, "DeferredDataError");
+var DeferredDataError = _DeferredDataError;
+async function readDeferredDataResponse(response) {
+  const contentType = response.headers.get("Content-Type") || "";
+  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
+    return await response.json();
+  }
+  if (!response.body) {
+    throw new DeferredDataError("Deferred route data response has no body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const controllers = /* @__PURE__ */ new Map();
+  let buffer = "";
+  let complete = false;
+  const readLine = /* @__PURE__ */ __name(async () => {
+    while (true) {
+      const newline = buffer.indexOf("\n");
+      if (newline >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        return line;
+      }
+      if (complete) {
+        if (!buffer) return void 0;
+        const line = buffer;
+        buffer = "";
+        return line;
+      }
+      const chunk = await reader.read();
+      complete = chunk.done;
+      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+      if (chunk.done) buffer += decoder.decode();
+    }
+  }, "readLine");
+  const firstLine = await readLine();
+  if (!firstLine) {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is empty");
+  }
+  const initial = parseDeferredMessage(firstLine);
+  if (initial.type !== "data") {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is invalid");
+  }
+  const data = reviveDeferredValue(initial.data, controllers);
+  void (async () => {
+    try {
+      for (let line = await readLine(); line !== void 0; line = await readLine()) {
+        if (!line) continue;
+        const message = parseDeferredMessage(line);
+        if (message.type === "resolve") {
+          const controller = getControlledDeferred(message.id, controllers);
+          controller.resolve(reviveDeferredValue(message.data, controllers));
+        } else if (message.type === "reject") {
+          getControlledDeferred(message.id, controllers).reject(
+            new DeferredDataError(message.error?.message)
+          );
+        }
+      }
+      rejectPendingDeferred(controllers, "Deferred route data stream ended before completion");
+    } catch {
+      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return data;
+}
+__name(readDeferredDataResponse, "readDeferredDataResponse");
+function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
+  if (isDeferredMarker(value)) {
+    const id = value[FARM_DEFERRED_MARKER];
+    const controller = getControlledDeferred(id, controllers);
+    const settlement = settlements?.[id];
+    if (settlement && controller.promise.status === "pending") {
+      if (applyingSettlements.has(id)) return controller.promise;
+      applyingSettlements.add(id);
+      if (settlement.status === "fulfilled") {
+        controller.resolve(
+          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements)
+        );
+      } else {
+        controller.reject(new DeferredDataError(settlement.error.message));
+      }
+      applyingSettlements.delete(id);
+    } else if (settlements && controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError("Deferred route data was not resolved"));
+    }
+    return controller.promise;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => reviveDeferredValue(item, controllers, settlements, applyingSettlements)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    output[key] = reviveDeferredValue(item, controllers, settlements, applyingSettlements);
+  }
+  return output;
+}
+__name(reviveDeferredValue, "reviveDeferredValue");
+function getControlledDeferred(id, controllers) {
+  const existing = controllers.get(id);
+  if (existing) return existing;
+  let nativeResolve;
+  let nativeReject;
+  const promise = new Promise((resolve, reject) => {
+    nativeResolve = resolve;
+    nativeReject = reject;
+  });
+  promise.status = "pending";
+  promise.catch(() => void 0);
+  const controlled = {
+    promise,
+    resolve(value) {
+      if (promise.status !== "pending") return;
+      promise.status = "fulfilled";
+      promise.value = value;
+      nativeResolve(value);
+    },
+    reject(error) {
+      if (promise.status !== "pending") return;
+      promise.status = "rejected";
+      promise.reason = error;
+      nativeReject(error);
+    }
+  };
+  controllers.set(id, controlled);
+  return controlled;
+}
+__name(getControlledDeferred, "getControlledDeferred");
+function isDeferredMarker(value) {
+  return Boolean(
+    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
+  );
+}
+__name(isDeferredMarker, "isDeferredMarker");
+function parseDeferredMessage(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new DeferredDataError("Deferred route data response contains invalid JSON");
+  }
+}
+__name(parseDeferredMessage, "parseDeferredMessage");
+function rejectPendingDeferred(controllers, message) {
+  for (const controller of controllers.values()) {
+    if (controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError(message));
+    }
+  }
+}
+__name(rejectPendingDeferred, "rejectPendingDeferred");
+
+// src/deployment.ts
+var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
+var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
+var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
+var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+var _FarmDeploymentMismatchError = class _FarmDeploymentMismatchError extends Error {
+  constructor(clientDeploymentId, serverDeploymentId) {
+    super("The application was updated while this page was open. Refresh before trying again.");
+    this.clientDeploymentId = clientDeploymentId;
+    this.serverDeploymentId = serverDeploymentId;
+    this.name = "FarmDeploymentMismatchError";
+    this.code = FARM_DEPLOYMENT_MISMATCH_CODE;
+    this.retryable = false;
+  }
+};
+__name(_FarmDeploymentMismatchError, "FarmDeploymentMismatchError");
+var FarmDeploymentMismatchError = _FarmDeploymentMismatchError;
+function createFarmDeploymentRequestHeaders(deploymentId, init) {
+  const headers = new Headers(init);
+  if (deploymentId) {
+    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  }
+  return headers;
+}
+__name(createFarmDeploymentRequestHeaders, "createFarmDeploymentRequestHeaders");
+function getFarmResponseDeploymentId(response) {
+  return response.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim() || void 0;
+}
+__name(getFarmResponseDeploymentId, "getFarmResponseDeploymentId");
+function isFarmDeploymentMismatchResponse(response, clientDeploymentId) {
+  const serverDeploymentId = getFarmResponseDeploymentId(response);
+  if (clientDeploymentId && serverDeploymentId && clientDeploymentId !== serverDeploymentId) {
+    return true;
+  }
+  return response.status === FARM_DEPLOYMENT_MISMATCH_STATUS && response.headers.get(FARM_DEPLOYMENT_MISMATCH_HEADER) === "1";
+}
+__name(isFarmDeploymentMismatchResponse, "isFarmDeploymentMismatchResponse");
+function createFarmDeploymentMismatchError(response, clientDeploymentId) {
+  return new FarmDeploymentMismatchError(
+    clientDeploymentId,
+    getFarmResponseDeploymentId(response) || "unknown"
+  );
+}
+__name(createFarmDeploymentMismatchError, "createFarmDeploymentMismatchError");
+
+// src/i18n/client-runtime.ts
+var import_intl_messageformat = __toESM(require("intl-messageformat"));
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function getActiveFarmI18nSnapshot() {
+  if (typeof window !== "undefined" && window.__FARM_I18N__) {
+    return window.__FARM_I18N__;
+  }
+  return globalThis[FARM_I18N_SNAPSHOT_RESOLVER]?.();
+}
+__name(getActiveFarmI18nSnapshot, "getActiveFarmI18nSnapshot");
+
+// src/i18n/routing.ts
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname2(pathname);
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+__name(resolveFarmLocalePath, "resolveFarmLocalePath");
+function stripFarmLocaleFromPathname(pathname, config) {
+  return resolveFarmLocalePath(pathname, config).pathname;
+}
+__name(stripFarmLocaleFromPathname, "stripFarmLocaleFromPathname");
+function normalizePathname2(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+__name(normalizePathname2, "normalizePathname");
+
+// src/i18n/client-runtime.ts
+var listeners = /* @__PURE__ */ new Set();
+var compiled = /* @__PURE__ */ new Map();
+var currentSnapshot;
+function getFarmI18nClientState() {
+  return currentSnapshot || getActiveFarmI18nSnapshot();
+}
+__name(getFarmI18nClientState, "getFarmI18nClientState");
+function _hydrateFarmI18n(snapshot) {
+  if (!snapshot) return;
+  const changed = currentSnapshot?.locale !== snapshot.locale;
+  currentSnapshot = snapshot;
+  if (typeof window !== "undefined") window.__FARM_I18N__ = snapshot;
+  if (typeof document !== "undefined") {
+    document.documentElement.lang = snapshot.locale;
+    document.documentElement.dir = snapshot.direction;
+  }
+  if (changed) compiled.clear();
+  for (const listener of listeners) listener();
+}
+__name(_hydrateFarmI18n, "_hydrateFarmI18n");
+var translate = /* @__PURE__ */ __name((key, values, rich = false) => {
+  const snapshot = requireSnapshot();
+  const message = snapshot.messages[key];
+  if (message === void 0) return key;
+  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
+  let formatter = compiled.get(cacheKey);
+  if (!formatter) {
+    formatter = new import_intl_messageformat.default(message, snapshot.locale);
+    compiled.set(cacheKey, formatter);
+  }
+  const result = formatter.format(values);
+  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+  }
+  return Array.isArray(result) ? result.join("") : String(result);
+}, "translate");
+var t = /* @__PURE__ */ __name(((key, values) => translate(key, values)), "t");
+t.rich = (key, values) => translate(key, values, true);
+t.raw = (key) => requireSnapshot().messages[key] ?? key;
+t.has = (key) => key in requireSnapshot().messages;
+function isFarmLocaleChangeHref(href) {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot || typeof window === "undefined") return false;
+  if (snapshot.routing === "none") return false;
+  const target = new URL(href, window.location.origin);
+  const match = resolveFarmLocalePath(target.pathname, snapshot);
+  const targetLocale = match.locale || snapshot.defaultLocale;
+  return targetLocale !== snapshot.locale;
+}
+__name(isFarmLocaleChangeHref, "isFarmLocaleChangeHref");
+function requireSnapshot() {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+__name(requireSnapshot, "requireSnapshot");
+
+// src/client/spa-router.ts
+var FARM_PAGE_STATE_KEY = "__farmPageState";
+var FARM_INTERCEPT_FROM_KEY = "__farmInterceptFrom";
+var IDLE_NAVIGATION_STATE = {
+  state: "idle",
+  pending: false,
+  from: null,
+  to: null,
+  action: null,
+  startedAt: null
+};
+var routerInstance = null;
+var _SPARouter = class _SPARouter {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.prefetchingUrls = /* @__PURE__ */ new Set();
+    this.observers = /* @__PURE__ */ new Map();
+    this.blockers = /* @__PURE__ */ new Set();
+    this.navigationListeners = /* @__PURE__ */ new Set();
+    this.navigationState = IDLE_NAVIGATION_STATE;
+    this.scrollElements = /* @__PURE__ */ new Map();
+    this.options = {
+      prefetchTimeout: options.prefetchTimeout ?? 100,
+      cacheMaxAge: options.cacheMaxAge ?? 3e4,
+      // 30 seconds
+      scrollRestoration: options.scrollRestoration ?? true,
+      shouldUseDocumentNavigation: options.shouldUseDocumentNavigation ?? (() => false),
+      deploymentId: options.deploymentId ?? readBrowserDeploymentId()
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("popstate", this.handlePopState.bind(this));
+      window.addEventListener("beforeunload", (event) => {
+        if (this.blockers.size > 0) {
+          event.preventDefault();
+          event.returnValue = "";
+        }
+        this.saveScrollPosition(window.location.pathname);
+      });
+    }
+  }
+  /**
+   * Set the navigation handler that updates React
+   */
+  setNavigationHandler(handler) {
+    this.onNavigate = handler;
+  }
+  /**
+   * Connect Farm's browser plugin lifecycle to SPA navigation.
+   */
+  setClientPluginManager(manager) {
+    this.clientPlugins = manager;
+  }
+  /**
+   * Navigate to a new URL
+   */
+  async navigate(href, options = {}) {
+    const { replace = false, scroll = true, state, viewTransition = false } = options;
+    const url = new URL(href, window.location.origin);
+    const pathname = url.pathname;
+    const search = url.search;
+    const fullPath = pathname + search;
+    if (isFarmLocaleChangeHref(url.toString()) || this.options.shouldUseDocumentNavigation(pathname)) {
+      if (replace) window.location.replace(url.toString());
+      else window.location.assign(url.toString());
+      return;
+    }
+    if (pathname === window.location.pathname && search === window.location.search) {
+      if (url.hash) {
+        window.location.hash = url.hash;
+      }
+      return;
+    }
+    const from = window.location.pathname + window.location.search;
+    if (await this.shouldBlockNavigation({
+      from,
+      to: fullPath,
+      action: replace ? "replace" : "push"
+    })) {
+      return;
+    }
+    if (this.options.scrollRestoration) {
+      this.saveScrollPosition(window.location.pathname);
+    }
+    this.startNavigation({
+      from,
+      to: createNavigationLocation(url),
+      action: replace ? "replace" : "push"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await this.clientPlugins?.beginNavigation({
+        from,
+        to: url,
+        action: replace ? "replace" : "push"
+      });
+      const pageData = await this.fetchPageData(fullPath, true, from);
+      if (clientNavigation) {
+        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
+      }
+      if (pageData.isClientComponent === false && !pageData.interception) {
+        this.finishNavigation();
+        window.location.assign(pageData.canonicalPath || fullPath);
+        return;
+      }
+      await this.runViewTransition(
+        viewTransition,
+        () => this.commitNavigation({
+          fullPath,
+          pageData,
+          pathname,
+          replace,
+          scroll,
+          state,
+          url
+        })
+      );
+      if (clientNavigation) {
+        await this.clientPlugins?.resolveNavigation(clientNavigation);
+        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
+      }
+      this.finishNavigation();
+    } catch (error) {
+      if (clientNavigation) {
+        await this.clientPlugins?.failNavigation(clientNavigation, error);
+      }
+      this.finishNavigation();
+      console.error("[Farm.js] Navigation error:", error);
+      window.location.href = href;
+    }
+  }
+  /**
+   * Prefetch a URL
+   */
+  async prefetch(href) {
+    if (isFarmLocaleChangeHref(href)) return;
+    const url = new URL(href, window.location.origin);
+    const fullPath = url.pathname + url.search;
+    const interceptFrom = window.location.pathname + window.location.search;
+    if (this.prefetchingUrls.has(fullPath)) return;
+    if (this.isCached(fullPath, interceptFrom)) return;
+    this.prefetchingUrls.add(fullPath);
+    try {
+      await this.fetchPageData(fullPath, false, interceptFrom);
+    } catch (error) {
+      console.warn("[Farm.js] Prefetch failed:", href, error);
+    } finally {
+      this.prefetchingUrls.delete(fullPath);
+    }
+  }
+  /**
+   * Observe an element for viewport intersection (prefetch when visible)
+   */
+  observeForPrefetch(element) {
+    if (typeof IntersectionObserver === "undefined") return;
+    const href = element.getAttribute("href");
+    if (!href || this.isExternalUrl(href)) return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            setTimeout(() => {
+              this.prefetch(href);
+            }, this.options.prefetchTimeout);
+            observer.unobserve(element);
+            this.observers.delete(element);
+          }
+        }
+      },
+      { rootMargin: "200px" }
+      // Start prefetching when 200px from viewport
+    );
+    observer.observe(element);
+    this.observers.set(element, observer);
+  }
+  /**
+   * Stop observing an element
+   */
+  unobserveForPrefetch(element) {
+    const observer = this.observers.get(element);
+    if (observer) {
+      observer.unobserve(element);
+      this.observers.delete(element);
+    }
+  }
+  addBlocker(blocker) {
+    this.blockers.add(blocker);
+    return () => {
+      this.blockers.delete(blocker);
+    };
+  }
+  getNavigationState() {
+    return this.navigationState;
+  }
+  subscribeNavigation(listener) {
+    this.navigationListeners.add(listener);
+    listener(this.navigationState);
+    return () => {
+      this.navigationListeners.delete(listener);
+    };
+  }
+  registerScrollElement(key, element) {
+    this.scrollElements.set(key, element);
+    this.restoreScrollElement(window.location.pathname, key, element);
+    return () => {
+      if (this.scrollElements.get(key) === element) {
+        this.scrollElements.delete(key);
+      }
+    };
+  }
+  pushState(state, href) {
+    this.writePageState("push", state, href);
+  }
+  replaceState(state, href) {
+    this.writePageState("replace", state, href);
+  }
+  async commitNavigation(options) {
+    const historyPath = options.pageData.canonicalPath || options.fullPath;
+    const historyState = createHistoryState(
+      historyPath,
+      options.state,
+      void 0,
+      options.pageData.interception?.from ?? null
+    );
+    if (options.replace) {
+      window.history.replaceState(historyState, "", historyPath);
+    } else {
+      window.history.pushState(historyState, "", historyPath);
+    }
+    if (options.pageData.metadata?.title) {
+      document.title = options.pageData.metadata.title;
+    }
+    if (options.pageData.metadata?.description) {
+      let metaDesc = document.querySelector('meta[name="description"]');
+      if (!metaDesc) {
+        metaDesc = document.createElement("meta");
+        metaDesc.setAttribute("name", "description");
+        document.head.appendChild(metaDesc);
+      }
+      metaDesc.setAttribute("content", options.pageData.metadata.description);
+    }
+    _hydrateFarmI18n(options.pageData.i18n);
+    if (this.onNavigate) {
+      await this.onNavigate(options.pageData);
+    }
+    if (options.scroll) {
+      if (options.url.hash) {
+        const element = document.querySelector(options.url.hash);
+        if (element) {
+          element.scrollIntoView();
+        }
+      } else {
+        window.scrollTo(0, 0);
+      }
+    } else if (this.options.scrollRestoration) {
+      this.restoreScrollPosition(options.pathname);
+    }
+  }
+  async runViewTransition(mode, callback) {
+    if (!mode || typeof document === "undefined") {
+      await callback();
+      return;
+    }
+    const startViewTransition = document.startViewTransition;
+    if (typeof startViewTransition !== "function") {
+      await callback();
+      return;
+    }
+    const transition = startViewTransition.call(document, () => callback());
+    const updateDone = transition?.updateCallbackDone || transition?.ready;
+    if (updateDone && typeof updateDone.then === "function") {
+      await updateDone;
+    }
+    transition?.finished?.catch?.(() => void 0);
+  }
+  /**
+   * Fetch page data from cache or server
+   */
+  async fetchPageData(path, recover = true, interceptFrom) {
+    const cacheKey = getPageDataCacheKey(path, interceptFrom);
+    const cached = this.cache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
+      return cached.data;
+    }
+    const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path)}`, {
+      headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
+        Accept: "application/x-farm-deferred+json, application/json",
+        "X-Farm-SPA": "1",
+        ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {}
+      })
+    });
+    if (isFarmDeploymentMismatchResponse(response, this.options.deploymentId)) {
+      const error = createFarmDeploymentMismatchError(
+        response,
+        this.options.deploymentId || "unknown"
+      );
+      dispatchDeploymentMismatch(error);
+      if (recover) {
+        window.location.assign(path);
+      }
+      throw error;
+    }
+    if (!response.ok) {
+      throw new Error(`Failed to fetch page data: ${response.status}`);
+    }
+    const data = await readDeferredDataResponse(response);
+    this.cache.set(cacheKey, {
+      data,
+      timestamp: Date.now()
+    });
+    return data;
+  }
+  /**
+   * Handle browser back/forward navigation
+   */
+  async handlePopState(event) {
+    if (document.documentElement.dataset.farmDocsRuntime === "true") return;
+    const path = window.location.pathname + window.location.search;
+    if (await this.shouldBlockNavigation({
+      from: event.state?.path || path,
+      to: path,
+      action: "pop"
+    })) {
+      return;
+    }
+    this.startNavigation({
+      from: event.state?.path || path,
+      to: createNavigationLocation(new URL(window.location.href)),
+      action: "pop"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await this.clientPlugins?.beginNavigation({
+        from: null,
+        to: window.location.href,
+        action: "pop"
+      });
+      const interceptFrom = typeof event.state?.[FARM_INTERCEPT_FROM_KEY] === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
+      const pageData = await this.fetchPageData(path, true, interceptFrom);
+      if (clientNavigation) {
+        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
+      }
+      if (pageData.metadata?.title) {
+        document.title = pageData.metadata.title;
+      }
+      _hydrateFarmI18n(pageData.i18n);
+      if (this.onNavigate) {
+        await this.onNavigate(pageData);
+      }
+      if (this.options.scrollRestoration) {
+        this.restoreScrollPosition(window.location.pathname);
+      }
+      if (clientNavigation) {
+        await this.clientPlugins?.resolveNavigation(clientNavigation);
+        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
+      }
+      this.finishNavigation();
+    } catch (error) {
+      if (clientNavigation) {
+        await this.clientPlugins?.failNavigation(clientNavigation, error);
+      }
+      this.finishNavigation();
+      console.error("[Farm.js] Popstate navigation error:", error);
+      window.location.reload();
+    }
+  }
+  /**
+   * Check if URL is cached
+   */
+  isCached(path, interceptFrom) {
+    const cached = this.cache.get(getPageDataCacheKey(path, interceptFrom));
+    return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
+  }
+  /**
+   * Check if URL is external
+   */
+  isExternalUrl(href) {
+    return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
+  }
+  async shouldBlockNavigation(context) {
+    for (const blocker of this.blockers) {
+      if (await blocker(context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  startNavigation(options) {
+    this.setNavigationState({
+      state: "loading",
+      pending: true,
+      from: options.from,
+      to: options.to,
+      action: options.action,
+      startedAt: Date.now()
+    });
+  }
+  finishNavigation() {
+    this.setNavigationState(IDLE_NAVIGATION_STATE);
+  }
+  setNavigationState(state) {
+    this.navigationState = state;
+    for (const listener of this.navigationListeners) {
+      listener(state);
+    }
+  }
+  writePageState(action, state, href) {
+    if (typeof window === "undefined") return;
+    const url = href ? new URL(href, window.location.origin).toString() : window.location.href;
+    const nextState = createHistoryState(
+      new URL(url).pathname + new URL(url).search,
+      state,
+      window.history.state
+    );
+    if (action === "replace") {
+      window.history.replaceState(nextState, "", url);
+    } else {
+      window.history.pushState(nextState, "", url);
+    }
+    window.dispatchEvent(new PopStateEvent("popstate", { state: nextState }));
+  }
+  /**
+   * Save scroll position for a path
+   */
+  saveScrollPosition(path) {
+    try {
+      sessionStorage.setItem(
+        `farm-scroll-${path}`,
+        JSON.stringify({ x: window.scrollX, y: window.scrollY })
+      );
+      for (const [key, element] of this.scrollElements) {
+        sessionStorage.setItem(
+          getScrollElementStorageKey(path, key),
+          JSON.stringify({ x: element.scrollLeft, y: element.scrollTop })
+        );
+      }
+    } catch {
+    }
+  }
+  /**
+   * Restore scroll position for a path
+   */
+  restoreScrollPosition(path) {
+    try {
+      const saved = sessionStorage.getItem(`farm-scroll-${path}`);
+      if (saved) {
+        const { x, y } = JSON.parse(saved);
+        setTimeout(() => window.scrollTo(x, y), 0);
+      }
+      for (const [key, element] of this.scrollElements) {
+        this.restoreScrollElement(path, key, element);
+      }
+    } catch {
+    }
+  }
+  restoreScrollElement(path, key, element) {
+    try {
+      const saved = sessionStorage.getItem(getScrollElementStorageKey(path, key));
+      if (!saved) return;
+      const { x, y } = JSON.parse(saved);
+      setTimeout(() => {
+        element.scrollLeft = x;
+        element.scrollTop = y;
+      }, 0);
+    } catch {
+    }
+  }
+  /**
+   * Clear the page cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+__name(_SPARouter, "SPARouter");
+var SPARouter = _SPARouter;
+function readBrowserDeploymentId() {
+  if (typeof window === "undefined") return void 0;
+  const runtimeId = window.__FARM_DEPLOYMENT_ID__;
+  if (typeof runtimeId === "string" && runtimeId) return runtimeId;
+  return document.querySelector('meta[name="farm-deployment-id"]')?.content;
+}
+__name(readBrowserDeploymentId, "readBrowserDeploymentId");
+function dispatchDeploymentMismatch(error) {
+  if (typeof window === "undefined" || typeof CustomEvent === "undefined") return;
+  window.dispatchEvent(new CustomEvent("farm:deployment-mismatch", { detail: error }));
+}
+__name(dispatchDeploymentMismatch, "dispatchDeploymentMismatch");
+function getRouter() {
+  if (typeof window === "undefined") {
+    return new SPARouter();
+  }
+  const installedRouter = window.__FARM_SPA_ROUTER__;
+  if (installedRouter) {
+    routerInstance = installedRouter;
+    return installedRouter;
+  }
+  if (!routerInstance) {
+    routerInstance = new SPARouter();
+  }
+  return routerInstance;
+}
+__name(getRouter, "getRouter");
+function readPageState() {
+  if (typeof window === "undefined") return null;
+  const state = window.history.state;
+  if (!state || typeof state !== "object") return null;
+  return state[FARM_PAGE_STATE_KEY] ?? null;
+}
+__name(readPageState, "readPageState");
+function createHistoryState(path, pageState, currentState, interceptFrom) {
+  const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
+  const nextState = {
+    ...base,
+    path,
+    [FARM_PAGE_STATE_KEY]: pageState
+  };
+  if (interceptFrom === null) {
+    delete nextState[FARM_INTERCEPT_FROM_KEY];
+  } else if (interceptFrom) {
+    nextState[FARM_INTERCEPT_FROM_KEY] = interceptFrom;
+  }
+  return nextState;
+}
+__name(createHistoryState, "createHistoryState");
+function getPageDataCacheKey(path, interceptFrom) {
+  return interceptFrom ? `${path}
+intercept:${interceptFrom}` : path;
+}
+__name(getPageDataCacheKey, "getPageDataCacheKey");
+function createNavigationLocation(url) {
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+__name(createNavigationLocation, "createNavigationLocation");
+function getScrollElementStorageKey(path, key) {
+  return `farm-scroll-${path}:${key}`;
+}
+__name(getScrollElementStorageKey, "getScrollElementStorageKey");
+
+// src/client/router.ts
+function useRouter(options = {}) {
+  const basePath = options.basePath || "";
+  const routes = options.routes;
+  const routeKey = routes?.map((route) => typeof route === "string" ? route : route.path).join("\n") || "";
+  const routeMatcher = (0, import_react.useMemo)(
+    () => routeKey ? createFarmRouter(routeKey.split("\n")) : null,
+    [routeKey]
+  );
+  const [state, setState] = (0, import_react.useState)(() => {
+    return readRouterState(basePath, routeMatcher);
+  });
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const handlePopState = /* @__PURE__ */ __name(() => {
+      setState(readRouterState(basePath, routeMatcher));
+    }, "handlePopState");
+    handlePopState();
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, [basePath, routeMatcher]);
+  const push = /* @__PURE__ */ __name((href) => {
+    if (typeof window === "undefined") return;
+    const url = href.startsWith("/") ? basePath + href : href;
+    window.history.pushState(null, "", url);
+    window.dispatchEvent(new PopStateEvent("popstate"));
+  }, "push");
+  const replace = /* @__PURE__ */ __name((href) => {
+    if (typeof window === "undefined") return;
+    const url = href.startsWith("/") ? basePath + href : href;
+    window.history.replaceState(null, "", url);
+    window.dispatchEvent(new PopStateEvent("popstate"));
+  }, "replace");
+  const pushState = /* @__PURE__ */ __name((pageState, href) => {
+    if (typeof window === "undefined") return;
+    getRouter().pushState(pageState, resolveClientHref(href, basePath));
+  }, "pushState");
+  const replaceState = /* @__PURE__ */ __name((pageState, href) => {
+    if (typeof window === "undefined") return;
+    getRouter().replaceState(pageState, resolveClientHref(href, basePath));
+  }, "replaceState");
+  const back = /* @__PURE__ */ __name(() => {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  }, "back");
+  const forward = /* @__PURE__ */ __name(() => {
+    if (typeof window !== "undefined") {
+      window.history.forward();
+    }
+  }, "forward");
+  return {
+    ...state,
+    push,
+    replace,
+    pushState,
+    replaceState,
+    back,
+    forward
+  };
+}
+__name(useRouter, "useRouter");
+function readRouterState(basePath, routeMatcher) {
+  if (typeof window === "undefined") {
+    return {
+      pathname: "/",
+      searchParams: new URLSearchParams(),
+      params: {},
+      pageState: null
+    };
+  }
+  const url = new URL(window.location.href);
+  const pathname = normalizeClientPathname(url.pathname, basePath);
+  const i18n = getFarmI18nClientState();
+  const routePathname = i18n ? stripFarmLocaleFromPathname(pathname, i18n) : pathname;
+  return {
+    pathname,
+    searchParams: url.searchParams,
+    params: routeMatcher?.match(routePathname)?.params || {},
+    pageState: readPageState()
+  };
+}
+__name(readRouterState, "readRouterState");
+function normalizeClientPathname(pathname, basePath) {
+  const normalizedBase = basePath.replace(/\/+$/, "");
+  const isUnderBase = normalizedBase && (pathname === normalizedBase || pathname.startsWith(`${normalizedBase}/`));
+  const withoutBase = isUnderBase ? pathname.slice(normalizedBase.length) || "/" : pathname;
+  return withoutBase || "/";
+}
+__name(normalizeClientPathname, "normalizeClientPathname");
+function resolveClientHref(href, basePath) {
+  if (!href) return void 0;
+  return href.startsWith("/") ? basePath + href : href;
+}
+__name(resolveClientHref, "resolveClientHref");
+
+// src/navigation-errors.ts
+var REDIRECT_ERROR_CODE = "FARM_REDIRECT";
+var NOT_FOUND_ERROR_CODE = "FARM_NOT_FOUND";
+var REDIRECT_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.redirect");
+var NOT_FOUND_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.notFound");
+function redirect(url, status = 307) {
+  throw createRedirectError(url, status);
+}
+__name(redirect, "redirect");
+function permanentRedirect(url) {
+  redirect(url, 308);
+}
+__name(permanentRedirect, "permanentRedirect");
+function notFound() {
+  const error = new Error(NOT_FOUND_ERROR_CODE);
+  error.digest = NOT_FOUND_ERROR_CODE;
+  error[NOT_FOUND_ERROR_SYMBOL] = true;
+  throw error;
+}
+__name(notFound, "notFound");
+function isFarmRedirectError(error) {
+  return Boolean(getFarmRedirectError(error));
+}
+__name(isFarmRedirectError, "isFarmRedirectError");
+function getFarmRedirectError(error) {
+  if (!error || typeof error !== "object") return null;
+  const candidate = error;
+  if (candidate[REDIRECT_ERROR_SYMBOL]) {
+    return candidate[REDIRECT_ERROR_SYMBOL];
+  }
+  if (typeof candidate.digest === "string" && candidate.digest.startsWith(`${REDIRECT_ERROR_CODE};`)) {
+    const [, status, ...urlParts] = candidate.digest.split(";");
+    const parsedStatus = Number(status);
+    if (isRedirectStatus(parsedStatus)) {
+      return {
+        status: parsedStatus,
+        url: urlParts.join(";")
+      };
+    }
+  }
+  return null;
+}
+__name(getFarmRedirectError, "getFarmRedirectError");
+function isFarmNotFoundError(error) {
+  if (!error || typeof error !== "object") return false;
+  const candidate = error;
+  return Boolean(candidate[NOT_FOUND_ERROR_SYMBOL] || candidate.digest === NOT_FOUND_ERROR_CODE);
+}
+__name(isFarmNotFoundError, "isFarmNotFoundError");
+function createRedirectError(url, status) {
+  const error = new Error(`${REDIRECT_ERROR_CODE};${status};${url}`);
+  error.digest = `${REDIRECT_ERROR_CODE};${status};${url}`;
+  error[REDIRECT_ERROR_SYMBOL] = { url, status };
+  return error;
+}
+__name(createRedirectError, "createRedirectError");
+function isRedirectStatus(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+__name(isRedirectStatus, "isRedirectStatus");
+
+// src/navigation.ts
+function useRouter2() {
+  const router = useRouter();
+  return {
+    push: router.push,
+    replace: router.replace,
+    back: router.back,
+    forward: router.forward,
+    refresh() {
+      if (typeof window !== "undefined") {
+        window.location.reload();
+      }
+    },
+    prefetch(_href) {
+      return Promise.resolve();
+    }
+  };
+}
+__name(useRouter2, "useRouter");
+function usePathname() {
+  return useRouter().pathname;
+}
+__name(usePathname, "usePathname");
+function useSearchParams() {
+  return useRouter().searchParams;
+}
+__name(useSearchParams, "useSearchParams");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFarmRedirectError,
+  isFarmNotFoundError,
+  isFarmRedirectError,
+  notFound,
+  permanentRedirect,
+  redirect,
+  usePathname,
+  useRouter,
+  useSearchParams
+});
+//# sourceMappingURL=navigation.cjs.map