@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-HELQXYVI.cjs

@@ -0,0 +1,1093 @@
+"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 _chunkRI3EVPKDcjs = require('./chunk-RI3EVPKD.cjs');
+
+
+var _chunkV7KTQR4Ccjs = require('./chunk-V7KTQR4C.cjs');
+
+
+
+
+var _chunkQQ44FYROcjs = require('./chunk-QQ44FYRO.cjs');
+
+
+var _chunkPENBZAHJcjs = require('./chunk-PENBZAHJ.cjs');
+
+
+
+
+var _chunk6IOZPJ3Icjs = require('./chunk-6IOZPJ3I.cjs');
+
+
+var _chunkCQL5ZGFUcjs = require('./chunk-CQL5ZGFU.cjs');
+
+
+
+
+var _chunkE552H232cjs = require('./chunk-E552H232.cjs');
+
+
+var _chunkXQSYOVCWcjs = require('./chunk-XQSYOVCW.cjs');
+
+// src/client/metadata-reconciler.ts
+var MANAGED_ATTRIBUTE = _chunk6IOZPJ3Icjs.FARM_METADATA_ATTRIBUTE;
+var OWNED_SELECTORS = [
+  'meta[name="description"]',
+  'meta[name="keywords"]',
+  'meta[name="author"]',
+  'meta[name="google-site-verification"]',
+  'meta[name="msvalidate.01"]',
+  'meta[name="yandex-verification"]',
+  'meta[name="creator"]',
+  'meta[name="publisher"]',
+  'meta[name="robots"]',
+  'meta[name="googlebot"]',
+  'link[rel="author"]',
+  'link[rel="canonical"]',
+  'link[rel="alternate"]',
+  'meta[property^="og:"]',
+  'meta[property^="article:"]',
+  'meta[name^="twitter:"]',
+  // Meta tags named by the app carry the marker, since no fixed name matches them.
+  `meta[${MANAGED_ATTRIBUTE}]`
+].join(", ");
+var ICON_SELECTORS = [
+  'link[rel="icon"]',
+  'link[rel="shortcut icon"]',
+  'link[rel="apple-touch-icon"]'
+].join(", ");
+var MANIFEST_SELECTOR = 'link[rel="manifest"]';
+var PAGE_JSON_LD_SELECTOR = `script[type="application/ld+json"][${MANAGED_ATTRIBUTE}]`;
+function removeAll(selector) {
+  for (const element of Array.from(document.head.querySelectorAll(selector))) {
+    element.remove();
+  }
+}
+function applyFarmMetadataToDocument(metadata, pathname) {
+  document.title = _chunk6IOZPJ3Icjs.resolveMetadataTitle.call(void 0, _optionalChain([metadata, 'optionalAccess', _ => _.title])) || "Farm.js App";
+  const rendered = _chunk6IOZPJ3Icjs.renderMetadataHead.call(void 0, metadata, { pathname });
+  const template = document.createElement("template");
+  template.innerHTML = rendered.tags;
+  const viewport = document.createElement("template");
+  viewport.innerHTML = rendered.viewport;
+  removeAll(OWNED_SELECTORS);
+  const charset = document.head.querySelector("meta[charset]");
+  for (const element of Array.from(viewport.content.children).reverse()) {
+    const name = element.getAttribute("name");
+    if (name && document.head.querySelector(`meta[name="${name}"]:not([${MANAGED_ATTRIBUTE}])`)) {
+      continue;
+    }
+    document.head.insertBefore(element, charset ? charset.nextSibling : document.head.firstChild);
+  }
+  removeAll(PAGE_JSON_LD_SELECTOR);
+  if (_optionalChain([metadata, 'optionalAccess', _2 => _2.icons])) removeAll(ICON_SELECTORS);
+  if (_optionalChain([metadata, 'optionalAccess', _3 => _3.manifest])) removeAll(MANIFEST_SELECTOR);
+  for (const element of Array.from(template.content.children)) {
+    element.setAttribute(MANAGED_ATTRIBUTE, "");
+    document.head.appendChild(element);
+  }
+}
+
+// src/client/spa-router.ts
+var MAX_CONCURRENT_VIEWPORT_PREFETCHES = 4;
+var FARM_PAGE_STATE_KEY = "__farmPageState";
+var FARM_INTERCEPT_FROM_KEY = "__farmInterceptFrom";
+var FARM_HISTORY_INDEX_KEY = "__farmHistoryIndex";
+function readHistoryIndex(state) {
+  if (!state || typeof state !== "object") return null;
+  const value = state[FARM_HISTORY_INDEX_KEY];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var IDLE_NAVIGATION_STATE = {
+  state: "idle",
+  pending: false,
+  from: null,
+  to: null,
+  action: null,
+  startedAt: null
+};
+function getActiveLayoutChainHeader() {
+  if (typeof document === "undefined") return void 0;
+  const patterns = Array.from(
+    document.querySelectorAll('[data-farm-layout-boundary="true"]')
+  ).map((element) => element.dataset.farmLayoutPattern).filter((pattern) => Boolean(pattern));
+  return patterns.length > 0 ? JSON.stringify(patterns) : void 0;
+}
+var routerInstance = null;
+var SPARouter = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.prefetchingUrls = /* @__PURE__ */ new Set();
+    this.pendingPrefetches = /* @__PURE__ */ new Map();
+    this.cacheGeneration = 0;
+    this.observedPrefetchLinks = /* @__PURE__ */ new Map();
+    this.prefetchTimers = /* @__PURE__ */ new Map();
+    this.viewportPrefetchQueue = [];
+    this.viewportPrefetchTasksByHref = /* @__PURE__ */ new Map();
+    this.viewportPrefetchTasksByElement = /* @__PURE__ */ new Map();
+    this.activeViewportPrefetches = 0;
+    this.destroyed = false;
+    this.blockers = /* @__PURE__ */ new Set();
+    this.unloadBlockers = /* @__PURE__ */ new Map();
+    this.navigationListeners = /* @__PURE__ */ new Set();
+    this.navigationState = IDLE_NAVIGATION_STATE;
+    this.currentHistoryPath = null;
+    this.currentHistoryHash = "";
+    this.currentHistoryIndex = null;
+    this.suppressNextPopState = false;
+    this.navigationSequence = 0;
+    this.scrollElements = /* @__PURE__ */ new Map();
+    this.onPopState = (event) => {
+      void this.handlePopState(event);
+    };
+    this.onBeforeUnload = (event) => {
+      if (this.shouldBlockUnload()) {
+        event.preventDefault();
+        event.returnValue = "";
+      }
+      this.saveScrollPosition(window.location.pathname + window.location.search);
+    };
+    this.options = {
+      prefetchTimeout: _nullishCoalesce(options.prefetchTimeout, () => ( 100)),
+      cacheMaxAge: _nullishCoalesce(options.cacheMaxAge, () => ( 3e4)),
+      // 30 seconds
+      scrollRestoration: _nullishCoalesce(options.scrollRestoration, () => ( true)),
+      shouldUseDocumentNavigation: _nullishCoalesce(options.shouldUseDocumentNavigation, () => ( (() => false))),
+      deploymentId: _nullishCoalesce(options.deploymentId, () => ( readBrowserDeploymentId()))
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("popstate", this.onPopState);
+      window.addEventListener("beforeunload", this.onBeforeUnload);
+      this.currentHistoryPath = window.location.pathname + window.location.search;
+      this.currentHistoryHash = window.location.hash;
+      this.currentInterceptFrom = _optionalChain([window, 'access', _4 => _4.history, 'access', _5 => _5.state, 'optionalAccess', _6 => _6[FARM_INTERCEPT_FROM_KEY]]);
+      const existingIndex = readHistoryIndex(window.history.state);
+      if (existingIndex == null) {
+        try {
+          window.history.replaceState(
+            {
+              ..._nullishCoalesce(window.history.state, () => ( {})),
+              [FARM_HISTORY_INDEX_KEY]: 0
+            },
+            "",
+            window.location.href
+          );
+          this.currentHistoryIndex = 0;
+        } catch (e) {
+          this.currentHistoryIndex = null;
+        }
+      } else {
+        this.currentHistoryIndex = existingIndex;
+      }
+    }
+  }
+  /** Remove global listeners. Intended for tests and teardown. */
+  destroy() {
+    if (typeof window === "undefined") return;
+    this.destroyed = true;
+    this.cancelActiveNavigation();
+    this.clearCache();
+    _optionalChain([this, 'access', _7 => _7.prefetchObserver, 'optionalAccess', _8 => _8.disconnect, 'call', _9 => _9()]);
+    this.prefetchObserver = void 0;
+    for (const timer of this.prefetchTimers.values()) clearTimeout(timer);
+    this.observedPrefetchLinks.clear();
+    this.prefetchTimers.clear();
+    for (const task of this.viewportPrefetchQueue) task.cancelled = true;
+    this.viewportPrefetchQueue.length = 0;
+    this.viewportPrefetchTasksByHref.clear();
+    this.viewportPrefetchTasksByElement.clear();
+    window.removeEventListener("popstate", this.onPopState);
+    window.removeEventListener("beforeunload", this.onBeforeUnload);
+  }
+  /**
+   * 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,
+      refresh = false
+    } = options;
+    const url = _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, href, window.location.href);
+    if (_chunkQQ44FYROcjs.isFarmBlockedNavigationURL.call(void 0, url)) return;
+    const pathname = url.pathname;
+    const search = url.search;
+    const fullPath = pathname + search;
+    if (_chunkQQ44FYROcjs.isFarmExternalNavigationURL.call(void 0, url, window.location.origin) || _chunkRI3EVPKDcjs.isFarmLocaleChangeHref.call(void 0, url.toString()) || this.options.shouldUseDocumentNavigation(pathname)) {
+      this.cancelActiveNavigation();
+      if (replace) window.location.replace(url.toString());
+      else window.location.assign(url.toString());
+      return;
+    }
+    if (!refresh && pathname === window.location.pathname && search === window.location.search) {
+      this.cancelActiveNavigation();
+      if (url.hash === window.location.hash) return;
+      this.writePageState(
+        replace ? "replace" : "push",
+        state === void 0 ? readPageState() : state,
+        url.toString()
+      );
+      if (scroll) {
+        if (url.hash) {
+          _optionalChain([_chunkV7KTQR4Ccjs.getHashTargetElement.call(void 0, url.hash), 'optionalAccess', _10 => _10.scrollIntoView, 'call', _11 => _11()]);
+        } else {
+          window.scrollTo(0, 0);
+        }
+      }
+      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 + window.location.search);
+    }
+    const navigation = this.startNavigation({
+      from,
+      to: createNavigationLocation(url),
+      action: replace ? "replace" : "push"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await _optionalChain([this, 'access', _12 => _12.clientPlugins, 'optionalAccess', _13 => _13.beginNavigation, 'call', _14 => _14({
+        from,
+        to: url,
+        action: replace ? "replace" : "push"
+      })]);
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      const pageData = await this.fetchPageData(
+        fullPath,
+        true,
+        from,
+        refresh,
+        navigation.controller.signal
+      );
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await _optionalChain([this, 'access', _15 => _15.clientPlugins, 'optionalAccess', _16 => _16.markNavigationLoaded, 'call', _17 => _17(clientNavigation, pageData)]);
+      }
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      await this.runViewTransition(
+        viewTransition,
+        () => this.isCurrentNavigation(navigation, clientNavigation) ? this.commitNavigation({
+          fullPath,
+          pageData,
+          pathname,
+          replace,
+          scroll,
+          state,
+          url,
+          refresh
+        }) : Promise.resolve()
+      );
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await _optionalChain([this, 'access', _18 => _18.clientPlugins, 'optionalAccess', _19 => _19.resolveNavigation, 'call', _20 => _20(clientNavigation)]);
+        void _optionalChain([this, 'access', _21 => _21.clientPlugins, 'optionalAccess', _22 => _22.scheduleNavigationRendered, 'call', _23 => _23(clientNavigation)]);
+      }
+      this.finishNavigation(navigation);
+    } catch (error) {
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await _optionalChain([this, 'access', _24 => _24.clientPlugins, 'optionalAccess', _25 => _25.failNavigation, 'call', _26 => _26(clientNavigation, error)]);
+      }
+      this.finishNavigation(navigation);
+      console.error("[Farm.js] Navigation error:", error);
+      window.location.href = href;
+    }
+  }
+  /**
+   * Re-render the active route from the server while preserving the document,
+   * shared layouts, client runtime, and browser history entry.
+   */
+  refresh(options = {}) {
+    return this.navigate(window.location.href, {
+      ...options,
+      replace: true,
+      refresh: true,
+      scroll: _nullishCoalesce(options.scroll, () => ( false))
+    });
+  }
+  /**
+   * Prefetch a URL
+   */
+  async prefetch(href) {
+    if (this.destroyed) return;
+    if (_chunkRI3EVPKDcjs.isFarmLocaleChangeHref.call(void 0, href)) return;
+    const url = _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, href, window.location.href);
+    if (_chunkQQ44FYROcjs.isFarmExternalNavigationURL.call(void 0, url, window.location.origin)) return;
+    if (this.options.shouldUseDocumentNavigation(url.pathname)) return;
+    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 (this.destroyed || typeof IntersectionObserver === "undefined") return;
+    const href = element.getAttribute("href");
+    if (!href || this.isExternalUrl(href)) return;
+    this.unobserveForPrefetch(element);
+    const observer = this.getPrefetchObserver();
+    this.observedPrefetchLinks.set(element, href);
+    observer.observe(element);
+  }
+  /**
+   * Stop observing an element
+   */
+  unobserveForPrefetch(element) {
+    if (this.observedPrefetchLinks.delete(element)) {
+      _optionalChain([this, 'access', _27 => _27.prefetchObserver, 'optionalAccess', _28 => _28.unobserve, 'call', _29 => _29(element)]);
+    }
+    const timer = this.prefetchTimers.get(element);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.prefetchTimers.delete(element);
+    }
+    this.cancelQueuedViewportPrefetch(element);
+  }
+  getPrefetchObserver() {
+    _nullishCoalesce(this.prefetchObserver, () => ( (this.prefetchObserver = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (!entry.isIntersecting) continue;
+          const element = entry.target;
+          const href = this.observedPrefetchLinks.get(element);
+          if (!href) continue;
+          _optionalChain([this, 'access', _30 => _30.prefetchObserver, 'optionalAccess', _31 => _31.unobserve, 'call', _32 => _32(element)]);
+          this.observedPrefetchLinks.delete(element);
+          const timer = setTimeout(() => {
+            if (this.prefetchTimers.get(element) !== timer) return;
+            this.prefetchTimers.delete(element);
+            this.enqueueViewportPrefetch(element, href);
+          }, this.options.prefetchTimeout);
+          this.prefetchTimers.set(element, timer);
+        }
+      },
+      { rootMargin: "200px" }
+    ))));
+    return this.prefetchObserver;
+  }
+  enqueueViewportPrefetch(element, href) {
+    if (this.destroyed) return;
+    let task = this.viewportPrefetchTasksByHref.get(href);
+    if (!task) {
+      task = { href, elements: /* @__PURE__ */ new Set(), cancelled: false, started: false };
+      this.viewportPrefetchTasksByHref.set(href, task);
+      this.viewportPrefetchQueue.push(task);
+    }
+    task.elements.add(element);
+    this.viewportPrefetchTasksByElement.set(element, task);
+    this.drainViewportPrefetchQueue();
+  }
+  cancelQueuedViewportPrefetch(element) {
+    const task = this.viewportPrefetchTasksByElement.get(element);
+    if (!task) return;
+    this.viewportPrefetchTasksByElement.delete(element);
+    task.elements.delete(element);
+    if (task.elements.size > 0) return;
+    if (task.started) return;
+    task.cancelled = true;
+    if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
+      this.viewportPrefetchTasksByHref.delete(task.href);
+    }
+  }
+  drainViewportPrefetchQueue() {
+    while (!this.destroyed && this.activeViewportPrefetches < MAX_CONCURRENT_VIEWPORT_PREFETCHES && this.viewportPrefetchQueue.length > 0) {
+      const task = this.viewportPrefetchQueue.shift();
+      if (task.cancelled || task.elements.size === 0) {
+        if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
+          this.viewportPrefetchTasksByHref.delete(task.href);
+        }
+        continue;
+      }
+      task.started = true;
+      this.activeViewportPrefetches += 1;
+      let prefetchResult;
+      try {
+        prefetchResult = this.prefetch(task.href);
+      } catch (e2) {
+        prefetchResult = void 0;
+      }
+      void Promise.resolve(prefetchResult).catch(() => void 0).finally(() => {
+        if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
+          this.viewportPrefetchTasksByHref.delete(task.href);
+        }
+        for (const element of task.elements) {
+          if (this.viewportPrefetchTasksByElement.get(element) === task) {
+            this.viewportPrefetchTasksByElement.delete(element);
+          }
+        }
+        this.activeViewportPrefetches -= 1;
+        this.drainViewportPrefetchQueue();
+      });
+    }
+  }
+  addBlocker(blocker, shouldBlockUnload) {
+    this.blockers.add(blocker);
+    this.unloadBlockers.set(
+      blocker,
+      _nullishCoalesce(shouldBlockUnload, () => ( (() => this.evaluateBlockerForUnload(blocker))))
+    );
+    return () => {
+      this.blockers.delete(blocker);
+      this.unloadBlockers.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 + window.location.search, 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);
+  }
+  /** @internal Keep shallow URL-search writes inside the router's history bookkeeping. */
+  writeURLSearch(action, href) {
+    this.writePageState(action, readPageState(), href, false);
+  }
+  async commitNavigation(options) {
+    const historyUrl = _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, 
+      options.pageData.canonicalPath || options.fullPath,
+      window.location.href
+    );
+    historyUrl.hash = options.url.hash;
+    const historyPath = historyUrl.pathname + historyUrl.search + historyUrl.hash;
+    const historyState = createHistoryState(
+      historyPath,
+      options.state,
+      options.replace ? window.history.state : void 0,
+      _nullishCoalesce(_optionalChain([options, 'access', _33 => _33.pageData, 'access', _34 => _34.interception, 'optionalAccess', _35 => _35.from]), () => ( null))
+    );
+    const nextHistoryIndex = this.currentHistoryIndex == null ? null : options.replace ? this.currentHistoryIndex : this.currentHistoryIndex + 1;
+    if (nextHistoryIndex != null) {
+      historyState[FARM_HISTORY_INDEX_KEY] = nextHistoryIndex;
+    }
+    if (options.replace) {
+      window.history.replaceState(historyState, "", historyPath);
+    } else {
+      window.history.pushState(historyState, "", historyPath);
+    }
+    this.currentHistoryIndex = nextHistoryIndex;
+    const resolvedHistoryUrl = _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, historyPath, window.location.href);
+    this.currentHistoryPath = resolvedHistoryUrl.pathname + resolvedHistoryUrl.search;
+    this.currentHistoryHash = resolvedHistoryUrl.hash;
+    this.currentInterceptFrom = historyState[FARM_INTERCEPT_FROM_KEY];
+    notifyRouterHistoryChange();
+    this.updateDocumentMetadata(options.pageData.metadata);
+    _chunkRI3EVPKDcjs._hydrateFarmI18n.call(void 0, options.pageData.i18n);
+    if (this.onNavigate) {
+      await this.onNavigate(options.pageData, { refresh: options.refresh === true });
+    }
+    if (options.scroll) {
+      if (options.url.hash) {
+        const element = _chunkV7KTQR4Ccjs.getHashTargetElement.call(void 0, options.url.hash);
+        if (element) {
+          element.scrollIntoView();
+        }
+      } else {
+        window.scrollTo(0, 0);
+      }
+    } else if (this.options.scrollRestoration) {
+      const restorePath = _nullishCoalesce(this.currentHistoryPath, () => ( options.fullPath));
+      this.restoreWindowScroll(restorePath);
+      this.restoreScrollElements(restorePath);
+    }
+  }
+  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 = _optionalChain([transition, 'optionalAccess', _36 => _36.updateCallbackDone]) || _optionalChain([transition, 'optionalAccess', _37 => _37.ready]);
+    if (updateDone && typeof updateDone.then === "function") {
+      await updateDone;
+    }
+    _optionalChain([transition, 'optionalAccess', _38 => _38.finished, 'optionalAccess', _39 => _39.catch, 'optionalCall', _40 => _40(() => void 0)]);
+  }
+  /**
+   * Fetch page data from cache or server
+   */
+  async fetchPageData(path, recover = true, interceptFrom, fresh = false, signal) {
+    const cacheKey = getPageDataCacheKey(path, interceptFrom);
+    const cached = fresh ? void 0 : this.cache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
+      return cached.data;
+    }
+    const activeLayoutChain = getActiveLayoutChainHeader();
+    const prefetchKey = JSON.stringify([path, interceptFrom, activeLayoutChain]);
+    let generation = this.cacheGeneration;
+    const pending = this.pendingPrefetches.get(prefetchKey);
+    if (pending && recover) {
+      if (fresh) {
+        pending.cacheable = false;
+        pending.resolve(void 0);
+        this.pendingPrefetches.delete(prefetchKey);
+      } else {
+        const cancellation = _chunkPENBZAHJcjs.createClientCancellation.call(void 0, signal);
+        try {
+          const data = await cancellation.run(() => pending.data);
+          cancellation.check();
+          if (data && pending.cacheable && generation === this.cacheGeneration) return data;
+        } finally {
+          cancellation.dispose();
+        }
+      }
+    }
+    generation = this.cacheGeneration;
+    let prefetch2;
+    if (!recover) {
+      let resolve;
+      const data = new Promise((done) => {
+        resolve = done;
+      });
+      prefetch2 = { data, resolve, cacheable: true };
+      this.pendingPrefetches.set(prefetchKey, prefetch2);
+    }
+    const cacheData = (data) => {
+      if (!this.destroyed && generation === this.cacheGeneration && _optionalChain([prefetch2, 'optionalAccess', _41 => _41.cacheable]) !== false) {
+        this.cachePageData(cacheKey, data);
+      }
+    };
+    try {
+      return await this.requestPageData(
+        path,
+        recover,
+        interceptFrom,
+        activeLayoutChain,
+        signal,
+        cacheData,
+        _optionalChain([prefetch2, 'optionalAccess', _42 => _42.resolve])
+      );
+    } finally {
+      _optionalChain([prefetch2, 'optionalAccess', _43 => _43.resolve, 'call', _44 => _44(void 0)]);
+      if (prefetch2 && this.pendingPrefetches.get(prefetchKey) === prefetch2) {
+        this.pendingPrefetches.delete(prefetchKey);
+      }
+    }
+  }
+  async requestPageData(path, recover, interceptFrom, activeLayoutChain, signal, cacheData, resolvePrefetch) {
+    const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path)}`, {
+      signal,
+      headers: _chunkE552H232cjs.createFarmDeploymentRequestHeaders.call(void 0, this.options.deploymentId, {
+        Accept: "application/x-farm-deferred+json, application/json",
+        "X-Farm-SPA": "1",
+        ...activeLayoutChain ? { "X-Farm-Layout-Chain": activeLayoutChain } : {},
+        ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {},
+        // Islands mode: the server leaves out island values this browser holds.
+        ..._chunkCQL5ZGFUcjs.getFarmIslandValueHeaders.call(void 0, )
+      })
+    });
+    if (_chunkE552H232cjs.isFarmDeploymentMismatchResponse.call(void 0, response, this.options.deploymentId)) {
+      const error = _chunkE552H232cjs.createFarmDeploymentMismatchError.call(void 0, 
+        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 isDeferredResponse = (response.headers.get("Content-Type") || "").toLowerCase().startsWith("application/x-farm-deferred+json");
+    if (!isDeferredResponse) {
+      const data2 = await _chunkXQSYOVCWcjs.readDeferredDataResponse.call(void 0, response);
+      cacheData(data2);
+      _optionalChain([resolvePrefetch, 'optionalCall', _45 => _45(data2)]);
+      return data2;
+    }
+    _optionalChain([resolvePrefetch, 'optionalCall', _46 => _46(void 0)]);
+    let data;
+    let streamCompleted = false;
+    const markStreamComplete = () => {
+      streamCompleted = true;
+      if (data) cacheData(data);
+    };
+    data = await _chunkXQSYOVCWcjs.readDeferredDataResponse.call(void 0, response, {
+      onComplete: markStreamComplete
+    });
+    if (streamCompleted) cacheData(data);
+    return data;
+  }
+  cachePageData(cacheKey, data) {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now - entry.timestamp >= this.options.cacheMaxAge) this.cache.delete(key);
+    }
+    this.cache.set(cacheKey, { data, timestamp: now });
+  }
+  /**
+   * Put the browser URL back on the rendered page after a blocked pop. When
+   * both entries carry a Farm history index the traversal is reversed
+   * exactly; otherwise the current path is pushed again, which restores the
+   * address bar at the cost of one extra history entry.
+   */
+  revertBlockedPopState(event, from) {
+    const eventIndex = readHistoryIndex(event.state);
+    if (eventIndex != null && this.currentHistoryIndex != null) {
+      const delta = eventIndex - this.currentHistoryIndex;
+      if (delta !== 0) {
+        this.suppressNextPopState = true;
+        window.history.go(-delta);
+        return;
+      }
+    }
+    try {
+      const restoredState = {
+        path: from
+      };
+      if (this.currentHistoryIndex != null && eventIndex != null) {
+        restoredState[FARM_HISTORY_INDEX_KEY] = eventIndex + 1;
+        this.currentHistoryIndex = eventIndex + 1;
+      }
+      window.history.pushState(restoredState, "", from);
+    } catch (e3) {
+    }
+  }
+  /**
+   * Handle browser back/forward navigation
+   */
+  async handlePopState(event) {
+    if (document.documentElement.dataset.farmDocsRuntime === "true") return;
+    if (this.suppressNextPopState) {
+      this.suppressNextPopState = false;
+      return;
+    }
+    const path = window.location.pathname + window.location.search;
+    const from = _nullishCoalesce(this.currentHistoryPath, () => ( path));
+    if (path === from && window.location.hash !== this.currentHistoryHash && _optionalChain([event, 'access', _47 => _47.state, 'optionalAccess', _48 => _48[FARM_INTERCEPT_FROM_KEY]]) === this.currentInterceptFrom) {
+      this.cancelActiveNavigation();
+      this.currentHistoryHash = window.location.hash;
+      this.currentHistoryIndex = readHistoryIndex(event.state);
+      return;
+    }
+    if (await this.shouldBlockNavigation({
+      from,
+      to: path,
+      action: "pop"
+    })) {
+      this.revertBlockedPopState(event, from);
+      return;
+    }
+    this.currentHistoryPath = path;
+    this.currentHistoryHash = window.location.hash;
+    this.currentInterceptFrom = _optionalChain([event, 'access', _49 => _49.state, 'optionalAccess', _50 => _50[FARM_INTERCEPT_FROM_KEY]]);
+    this.currentHistoryIndex = readHistoryIndex(event.state);
+    const navigation = this.startNavigation({
+      from,
+      to: createNavigationLocation(new URL(window.location.href)),
+      action: "pop"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await _optionalChain([this, 'access', _51 => _51.clientPlugins, 'optionalAccess', _52 => _52.beginNavigation, 'call', _53 => _53({
+        from: null,
+        to: window.location.href,
+        action: "pop"
+      })]);
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      const interceptFrom = typeof _optionalChain([event, 'access', _54 => _54.state, 'optionalAccess', _55 => _55[FARM_INTERCEPT_FROM_KEY]]) === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
+      const pageData = await this.fetchPageData(
+        path,
+        true,
+        interceptFrom,
+        false,
+        navigation.controller.signal
+      );
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await _optionalChain([this, 'access', _56 => _56.clientPlugins, 'optionalAccess', _57 => _57.markNavigationLoaded, 'call', _58 => _58(clientNavigation, pageData)]);
+      }
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      this.updateDocumentMetadata(pageData.metadata);
+      _chunkRI3EVPKDcjs._hydrateFarmI18n.call(void 0, pageData.i18n);
+      if (this.onNavigate) {
+        await this.onNavigate(pageData);
+      }
+      const destinationPath = window.location.pathname + window.location.search;
+      if (window.location.hash) {
+        const target = _chunkV7KTQR4Ccjs.getHashTargetElement.call(void 0, window.location.hash);
+        if (target) {
+          target.scrollIntoView();
+        } else if (this.options.scrollRestoration) {
+          this.restoreWindowScroll(destinationPath);
+        }
+      } else if (this.options.scrollRestoration) {
+        this.restoreWindowScroll(destinationPath);
+      }
+      if (this.options.scrollRestoration) {
+        this.restoreScrollElements(destinationPath);
+      }
+      if (clientNavigation) {
+        await _optionalChain([this, 'access', _59 => _59.clientPlugins, 'optionalAccess', _60 => _60.resolveNavigation, 'call', _61 => _61(clientNavigation)]);
+        void _optionalChain([this, 'access', _62 => _62.clientPlugins, 'optionalAccess', _63 => _63.scheduleNavigationRendered, 'call', _64 => _64(clientNavigation)]);
+      }
+      this.finishNavigation(navigation);
+    } catch (error) {
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await _optionalChain([this, 'access', _65 => _65.clientPlugins, 'optionalAccess', _66 => _66.failNavigation, 'call', _67 => _67(clientNavigation, error)]);
+      }
+      this.finishNavigation(navigation);
+      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;
+  }
+  evaluateBlockerForUnload(blocker) {
+    const path = window.location.pathname + window.location.search;
+    const result = blocker({ from: path, to: path, action: "replace" });
+    if (result && typeof result !== "boolean") {
+      void result.catch(() => void 0);
+      return true;
+    }
+    return result === true;
+  }
+  shouldBlockUnload() {
+    for (const blocker of this.blockers) {
+      try {
+        if (_optionalChain([this, 'access', _68 => _68.unloadBlockers, 'access', _69 => _69.get, 'call', _70 => _70(blocker), 'optionalCall', _71 => _71()])) return true;
+      } catch (e4) {
+        return true;
+      }
+    }
+    return false;
+  }
+  updateDocumentMetadata(metadata) {
+    applyFarmMetadataToDocument(metadata, window.location.pathname);
+  }
+  startNavigation(options) {
+    _optionalChain([this, 'access', _72 => _72.activeNavigation, 'optionalAccess', _73 => _73.controller, 'access', _74 => _74.abort, 'call', _75 => _75("superseded")]);
+    const navigation = {
+      id: ++this.navigationSequence,
+      controller: new AbortController()
+    };
+    this.activeNavigation = navigation;
+    this.setNavigationState({
+      state: "loading",
+      pending: true,
+      from: options.from,
+      to: options.to,
+      action: options.action,
+      startedAt: Date.now()
+    });
+    return navigation;
+  }
+  isCurrentNavigation(navigation, clientNavigation) {
+    return _optionalChain([this, 'access', _76 => _76.activeNavigation, 'optionalAccess', _77 => _77.id]) === navigation.id && !navigation.controller.signal.aborted && !_optionalChain([clientNavigation, 'optionalAccess', _78 => _78.signal, 'access', _79 => _79.aborted]);
+  }
+  finishNavigation(navigation) {
+    if (_optionalChain([this, 'access', _80 => _80.activeNavigation, 'optionalAccess', _81 => _81.id]) !== navigation.id) return;
+    this.activeNavigation = void 0;
+    this.setNavigationState(IDLE_NAVIGATION_STATE);
+  }
+  cancelActiveNavigation() {
+    if (!this.activeNavigation) return;
+    this.activeNavigation.controller.abort("superseded");
+    this.activeNavigation = void 0;
+    this.setNavigationState(IDLE_NAVIGATION_STATE);
+  }
+  setNavigationState(state) {
+    this.navigationState = state;
+    for (const listener of this.navigationListeners) {
+      listener(state);
+    }
+  }
+  writePageState(action, state, href, notify = true) {
+    if (typeof window === "undefined") return;
+    const url = href ? _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, href, window.location.href).toString() : window.location.href;
+    const parsedUrl = new URL(url);
+    const nextPath = parsedUrl.pathname + parsedUrl.search;
+    const historyPath = nextPath + parsedUrl.hash;
+    const nextState = createHistoryState(historyPath, state, window.history.state);
+    if (action === "replace") {
+      window.history.replaceState(nextState, "", url);
+    } else {
+      if (this.currentHistoryIndex != null) {
+        nextState[FARM_HISTORY_INDEX_KEY] = this.currentHistoryIndex + 1;
+      }
+      window.history.pushState(nextState, "", url);
+      this.currentHistoryIndex = this.currentHistoryIndex == null ? null : this.currentHistoryIndex + 1;
+    }
+    this.currentHistoryPath = nextPath;
+    this.currentHistoryHash = parsedUrl.hash;
+    this.currentInterceptFrom = nextState[FARM_INTERCEPT_FROM_KEY];
+    if (notify) notifyHistoryChange("page-state");
+  }
+  /**
+   * 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 (e5) {
+    }
+  }
+  /**
+   * Restore the saved window scroll position for a path.
+   */
+  restoreWindowScroll(path) {
+    try {
+      const saved = sessionStorage.getItem(`farm-scroll-${path}`);
+      if (saved) {
+        const { x, y } = JSON.parse(saved);
+        setTimeout(() => window.scrollTo(x, y), 0);
+      }
+    } catch (e6) {
+    }
+  }
+  /**
+   * Restore saved scroll positions for every registered scroll element. Keys
+   * are hash-stripped (see getScrollElementStorageKey), so this runs regardless
+   * of whether the destination URL carries a fragment.
+   */
+  restoreScrollElements(path) {
+    try {
+      for (const [key, element] of this.scrollElements) {
+        this.restoreScrollElement(path, key, element);
+      }
+    } catch (e7) {
+    }
+  }
+  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 (e8) {
+    }
+  }
+  /**
+   * Clear the page cache
+   */
+  clearCache() {
+    this.cacheGeneration += 1;
+    this.cache.clear();
+    for (const pending of this.pendingPrefetches.values()) {
+      pending.cacheable = false;
+      pending.resolve(void 0);
+    }
+    this.pendingPrefetches.clear();
+  }
+};
+function readBrowserDeploymentId() {
+  if (typeof window === "undefined") return void 0;
+  const runtimeId = window.__FARM_DEPLOYMENT_ID__;
+  if (typeof runtimeId === "string" && runtimeId) return runtimeId;
+  return _optionalChain([document, 'access', _82 => _82.querySelector, 'call', _83 => _83('meta[name="farm-deployment-id"]'), 'optionalAccess', _84 => _84.content]);
+}
+function dispatchDeploymentMismatch(error) {
+  if (typeof window === "undefined" || typeof CustomEvent === "undefined") return;
+  window.dispatchEvent(new CustomEvent("farm:deployment-mismatch", { detail: error }));
+}
+function getInstalledFarmSPARouter() {
+  if (typeof window === "undefined") return void 0;
+  return window.__FARM_SPA_ROUTER__;
+}
+function getRouter() {
+  if (typeof window === "undefined") {
+    return new SPARouter();
+  }
+  const installedRouter = getInstalledFarmSPARouter();
+  if (installedRouter) {
+    routerInstance = installedRouter;
+    return installedRouter;
+  }
+  if (!routerInstance) {
+    routerInstance = new SPARouter();
+  }
+  return routerInstance;
+}
+function navigateTo(href, options) {
+  return getRouter().navigate(href, options);
+}
+function prefetch(href) {
+  return getRouter().prefetch(href);
+}
+function pushState(state, href) {
+  getRouter().pushState(state, href);
+}
+function replaceState(state, href) {
+  getRouter().replaceState(state, href);
+}
+function readPageState() {
+  if (typeof window === "undefined") return null;
+  const state = window.history.state;
+  if (!state || typeof state !== "object") return null;
+  return _nullishCoalesce(state[FARM_PAGE_STATE_KEY], () => ( null));
+}
+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;
+}
+function getPageDataCacheKey(path, interceptFrom) {
+  return interceptFrom ? `${path}
+intercept:${interceptFrom}` : path;
+}
+function createNavigationLocation(url) {
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+function getScrollElementStorageKey(path, key) {
+  return `farm-scroll-${path}:${key}`;
+}
+
+// src/client/history-sync.ts
+var FARM_HISTORY_CHANGE_EVENT = "farm:historychange";
+function writeFarmURLSearchHistory(action, href) {
+  const router = getInstalledFarmSPARouter();
+  if (!router) return false;
+  const writeURLSearch = router.writeURLSearch;
+  if (typeof writeURLSearch !== "function") return false;
+  if (window.history.state !== null && typeof window.history.state !== "object") return false;
+  writeURLSearch.call(router, action, href);
+  return true;
+}
+function dispatchHistoryChange(kind) {
+  window.dispatchEvent(
+    new CustomEvent(FARM_HISTORY_CHANGE_EVENT, {
+      detail: { kind }
+    })
+  );
+}
+function notifyHistoryChange(kind) {
+  if (typeof window === "undefined") return;
+  setTimeout(() => {
+    if (kind === "url-search" && !getInstalledFarmSPARouter()) {
+      window.dispatchEvent(new PopStateEvent("popstate"));
+      return;
+    }
+    dispatchHistoryChange(kind);
+  }, 0);
+}
+function notifyRouterHistoryChange() {
+  if (typeof window === "undefined") return;
+  setTimeout(() => dispatchHistoryChange("url-search"), 0);
+}
+function subscribeHistoryChange(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  window.addEventListener("popstate", listener);
+  window.addEventListener(FARM_HISTORY_CHANGE_EVENT, listener);
+  return () => {
+    window.removeEventListener("popstate", listener);
+    window.removeEventListener(FARM_HISTORY_CHANGE_EVENT, listener);
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.writeFarmURLSearchHistory = writeFarmURLSearchHistory; exports.notifyHistoryChange = notifyHistoryChange; exports.subscribeHistoryChange = subscribeHistoryChange; exports.SPARouter = SPARouter; exports.getInstalledFarmSPARouter = getInstalledFarmSPARouter; exports.getRouter = getRouter; exports.navigateTo = navigateTo; exports.prefetch = prefetch; exports.pushState = pushState; exports.replaceState = replaceState; exports.readPageState = readPageState;