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

package/dist/chunk-WDU6QXNK.mjs

@@ -0,0 +1,872 @@
+import {
+  getAPIRouteRefMetadata,
+  isAPIRouteRef
+} from "./chunk-W2CRQFF6.mjs";
+import {
+  isFarmLocaleChangeHref,
+  localizeActiveFarmHref
+} from "./chunk-ITN462YM.mjs";
+import {
+  buildFarmRoutePath
+} from "./chunk-ZBE6MLHL.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/mutation-client.ts
+import { useCallback, useMemo, useRef, useState } from "react";
+function useMutation(target, options = {}) {
+  const initialData = options.initialData ?? null;
+  const optionsRef = useRef(options);
+  const targetRef = useRef(target);
+  const requestIdRef = useRef(0);
+  const initialState = {
+    pendingCount: 0,
+    status: "idle",
+    data: initialData,
+    error: null,
+    variables: void 0
+  };
+  const stateRef = useRef(initialState);
+  const [state, setState] = useState(initialState);
+  optionsRef.current = options;
+  targetRef.current = target;
+  const setMutationState = useCallback(
+    (value) => {
+      setState((current) => {
+        const next = typeof value === "function" ? value(current) : value;
+        stateRef.current = next;
+        return next;
+      });
+    },
+    []
+  );
+  const mutateAsync = useCallback(
+    async (variables) => {
+      const requestId = ++requestIdRef.current;
+      const currentOptions = optionsRef.current;
+      const previousData = stateRef.current.data;
+      const optimisticData = currentOptions.optimistic?.({
+        variables,
+        current: previousData
+      });
+      const hasOptimisticData = optimisticData !== void 0;
+      setMutationState((current) => ({
+        pendingCount: current.pendingCount + 1,
+        status: "pending",
+        data: hasOptimisticData ? optimisticData : currentOptions.resetOnMutate === false ? current.data : null,
+        error: null,
+        variables
+      }));
+      try {
+        const mutationTarget = targetRef.current;
+        const rawResult = isAPIRouteRef(mutationTarget) ? await mutationTarget(variables, currentOptions.request) : await mutationTarget(variables);
+        const data = unwrapMutationResult(rawResult, isAPIRouteRef(mutationTarget));
+        const isLatestRequest = requestId === requestIdRef.current;
+        setMutationState((current) => {
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount,
+              status: pendingCount > 0 ? "pending" : current.status
+            };
+          }
+          return {
+            pendingCount,
+            status: "success",
+            data,
+            error: null,
+            variables
+          };
+        });
+        if (isLatestRequest) {
+          currentOptions.onSuccess?.(data, variables);
+          currentOptions.onSettled?.(data, null, variables);
+        }
+        return data;
+      } catch (cause) {
+        const error = normalizeMutationError(cause);
+        const isLatestRequest = requestId === requestIdRef.current;
+        setMutationState((current) => {
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount,
+              status: pendingCount > 0 ? "pending" : current.status
+            };
+          }
+          return {
+            pendingCount,
+            status: "error",
+            data: hasOptimisticData && currentOptions.rollbackOnError ? previousData : currentOptions.resetOnMutate === false ? current.data : null,
+            error,
+            variables
+          };
+        });
+        if (isLatestRequest) {
+          currentOptions.onError?.(error, variables);
+          currentOptions.onSettled?.(null, error, variables);
+        }
+        throw error;
+      }
+    },
+    [setMutationState]
+  );
+  const mutate = useCallback(
+    (variables) => {
+      void mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  const reset = useCallback(() => {
+    requestIdRef.current += 1;
+    setMutationState({
+      pendingCount: 0,
+      status: "idle",
+      data: optionsRef.current.initialData ?? null,
+      error: null,
+      variables: void 0
+    });
+  }, [setMutationState]);
+  return useMemo(
+    () => ({
+      pending: state.pendingCount > 0,
+      status: state.status,
+      data: state.data,
+      error: state.error,
+      variables: state.variables,
+      mutate,
+      mutateAsync,
+      reset
+    }),
+    [
+      mutate,
+      mutateAsync,
+      reset,
+      state.data,
+      state.error,
+      state.pendingCount,
+      state.status,
+      state.variables
+    ]
+  );
+}
+__name(useMutation, "useMutation");
+function unwrapMutationResult(result, apiRoute) {
+  if (!apiRoute) return result;
+  const apiResult = result;
+  if (apiResult.error) {
+    throw apiResult.error;
+  }
+  return apiResult.data;
+}
+__name(unwrapMutationResult, "unwrapMutationResult");
+function normalizeMutationError(error) {
+  if (error instanceof Error) return error;
+  const normalized = new Error(typeof error === "string" ? error : "Mutation failed");
+  normalized.cause = error;
+  return normalized;
+}
+__name(normalizeMutationError, "normalizeMutationError");
+
+// src/fetcher-client.tsx
+import {
+  createElement,
+  useCallback as useCallback2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+var formDataContexts = /* @__PURE__ */ new WeakMap();
+function useFetcher(target, options = {}) {
+  const targetRef = useRef2(target);
+  const optionsRef = useRef2(options);
+  const submissionIdRef = useRef2(0);
+  const [formData, setFormData] = useState2(null);
+  const mutation = useMutation(target, options);
+  targetRef.current = target;
+  optionsRef.current = options;
+  const submitAsync = useCallback2(
+    async (input) => {
+      const submissionId = ++submissionIdRef.current;
+      const submittedFormData = isFormData(input) ? input : null;
+      setFormData(submittedFormData);
+      try {
+        const variables = submittedFormData ? mapFetcherFormData(targetRef.current, submittedFormData, optionsRef.current) : input;
+        return await mutation.mutateAsync(variables);
+      } finally {
+        if (submissionId === submissionIdRef.current) {
+          setFormData(null);
+        }
+      }
+    },
+    [mutation.mutateAsync]
+  );
+  const submit = useCallback2(
+    (input) => {
+      void submitAsync(input).catch(() => {
+      });
+    },
+    [submitAsync]
+  );
+  const Form = useMemo2(() => {
+    const FetcherForm = /* @__PURE__ */ __name(({ action, method, encType, onSubmit, ...props }) => {
+      const targetValue = targetRef.current;
+      const metadata = getAPIRouteRefMetadata(targetValue);
+      const nativeAction = action ?? resolveFetcherFormAction(targetValue, metadata);
+      const nativeMethod = method ?? (metadata && (metadata.method === "GET" || metadata.method === "POST") ? metadata.method.toLowerCase() : metadata ? "post" : void 0);
+      const functionAction = typeof nativeAction === "function";
+      const handleSubmit = /* @__PURE__ */ __name((event) => {
+        onSubmit?.(event);
+        if (event.defaultPrevented) return;
+        event.preventDefault();
+        const submitter = getSubmitter(event);
+        const nextFormData = createSubmitterFormData(event.currentTarget, submitter);
+        formDataContexts.set(nextFormData, {
+          form: event.currentTarget,
+          submitter
+        });
+        void submitAsync(nextFormData).catch(() => {
+        });
+      }, "handleSubmit");
+      return createElement("form", {
+        ...props,
+        action: nativeAction,
+        method: functionAction ? void 0 : nativeMethod,
+        encType: functionAction ? void 0 : encType,
+        onSubmit: handleSubmit
+      });
+    }, "FetcherForm");
+    FetcherForm.displayName = "FetcherForm";
+    return FetcherForm;
+  }, [submitAsync]);
+  const reset = useCallback2(() => {
+    submissionIdRef.current += 1;
+    setFormData(null);
+    mutation.reset();
+  }, [mutation.reset]);
+  return useMemo2(
+    () => ({
+      state: mutation.pending ? "submitting" : "idle",
+      status: mutation.status,
+      pending: mutation.pending,
+      data: mutation.data,
+      error: mutation.error,
+      variables: mutation.variables,
+      formData,
+      submit,
+      submitAsync,
+      Form,
+      reset
+    }),
+    [
+      Form,
+      formData,
+      mutation.data,
+      mutation.error,
+      mutation.pending,
+      mutation.status,
+      mutation.variables,
+      reset,
+      submit,
+      submitAsync
+    ]
+  );
+}
+__name(useFetcher, "useFetcher");
+function mapFetcherFormData(target, formData, options) {
+  const context = formDataContexts.get(formData) ?? { form: null, submitter: null };
+  if (options.mapFormData) {
+    return options.mapFormData(formData, context);
+  }
+  if (!isAPIRouteRef(target)) {
+    return formData;
+  }
+  const values = formDataToObject(formData);
+  const method = getAPIRouteRefMetadata(target)?.method;
+  return method === "GET" || method === "HEAD" ? { query: values } : { body: values };
+}
+__name(mapFetcherFormData, "mapFetcherFormData");
+function resolveFetcherFormAction(target, metadata) {
+  if (!metadata) return isProgressiveFormAction(target) ? target : void 0;
+  if (metadata.sameOrigin) return metadata.path;
+  return new URL(metadata.path, metadata.baseURL).href;
+}
+__name(resolveFetcherFormAction, "resolveFetcherFormAction");
+function formDataToObject(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.entries()) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
+__name(formDataToObject, "formDataToObject");
+function createSubmitterFormData(form, submitter) {
+  try {
+    return new FormData(form, submitter);
+  } catch {
+    const formData = new FormData(form);
+    const candidate = submitter;
+    if (candidate && !candidate.disabled && candidate.name) {
+      formData.append(candidate.name, candidate.value ?? "");
+    }
+    return formData;
+  }
+}
+__name(createSubmitterFormData, "createSubmitterFormData");
+function getSubmitter(event) {
+  const nativeEvent = event.nativeEvent;
+  return nativeEvent.submitter instanceof HTMLElement ? nativeEvent.submitter : null;
+}
+__name(getSubmitter, "getSubmitter");
+function isProgressiveFormAction(target) {
+  const candidate = target;
+  return candidate.__farmServerFn === true || typeof candidate.$$FORM_ACTION === "function" || candidate.$$typeof === /* @__PURE__ */ Symbol.for("react.server.reference");
+}
+__name(isProgressiveFormAction, "isProgressiveFormAction");
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  return typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+__name(isFormData, "isFormData");
+
+// src/store.ts
+import { useSyncExternalStore } from "react";
+var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
+  "use",
+  "get",
+  "set",
+  "replace",
+  "reset",
+  "subscribe"
+]);
+function cloneState(state) {
+  return { ...state };
+}
+__name(cloneState, "cloneState");
+function pickState(state, keys) {
+  const slice = {};
+  for (const key of keys) {
+    slice[key] = state[key];
+  }
+  return slice;
+}
+__name(pickState, "pickState");
+function getChangedKeys(state, previousState) {
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(state),
+    ...Object.keys(previousState)
+  ]);
+  return [...keys].filter((key) => !Object.is(state[key], previousState[key]));
+}
+__name(getChangedKeys, "getChangedKeys");
+function normalizeKeys(keys) {
+  return Array.from(new Set(keys));
+}
+__name(normalizeKeys, "normalizeKeys");
+function resolveValue(value, previousValue) {
+  return typeof value === "function" ? value(previousValue) : value;
+}
+__name(resolveValue, "resolveValue");
+function isStoreKey(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+__name(isStoreKey, "isStoreKey");
+function createStore(initialState, extend) {
+  const initialSnapshot = cloneState(initialState);
+  let state = cloneState(initialState);
+  const subscriptions = /* @__PURE__ */ new Set();
+  const addSubscription = /* @__PURE__ */ __name((keys, notify) => {
+    const subscription = { keys, notify };
+    subscriptions.add(subscription);
+    return () => {
+      subscriptions.delete(subscription);
+    };
+  }, "addSubscription");
+  const emit = /* @__PURE__ */ __name((nextState, previousState) => {
+    const changedKeys = getChangedKeys(nextState, previousState);
+    if (changedKeys.length === 0) {
+      return;
+    }
+    const changedKeySet = new Set(changedKeys);
+    for (const subscription of subscriptions) {
+      if (subscription.keys === null || subscription.keys.some((key) => changedKeySet.has(key))) {
+        subscription.notify(nextState, previousState);
+      }
+    }
+  }, "emit");
+  const getState = /* @__PURE__ */ __name((key) => {
+    return key === void 0 ? state : state[key];
+  }, "getState");
+  const replaceState2 = /* @__PURE__ */ __name((nextState) => {
+    const previousState = state;
+    const resolvedState = typeof nextState === "function" ? nextState(previousState) : nextState;
+    state = resolvedState;
+    emit(state, previousState);
+    return state;
+  }, "replaceState");
+  const setState = /* @__PURE__ */ __name((keyOrPatch, value) => {
+    const previousState = state;
+    let nextState;
+    if (isStoreKey(keyOrPatch)) {
+      const key = keyOrPatch;
+      const nextValue = resolveValue(value, previousState[key]);
+      if (Object.is(previousState[key], nextValue)) {
+        return nextValue;
+      }
+      nextState = {
+        ...previousState,
+        [key]: nextValue
+      };
+      state = nextState;
+      emit(nextState, previousState);
+      return nextValue;
+    }
+    const patch = typeof keyOrPatch === "function" ? keyOrPatch(previousState) : keyOrPatch;
+    nextState = {
+      ...previousState,
+      ...patch
+    };
+    state = nextState;
+    emit(nextState, previousState);
+    return nextState;
+  }, "setState");
+  const subscribeState = /* @__PURE__ */ __name((keyOrListener, listener) => {
+    if (typeof keyOrListener === "function") {
+      return addSubscription(null, (nextState, previousState) => {
+        keyOrListener(nextState, previousState);
+      });
+    }
+    if (Array.isArray(keyOrListener)) {
+      const keys = normalizeKeys(keyOrListener);
+      return addSubscription(keys, (nextState, previousState) => {
+        listener(
+          pickState(nextState, keys),
+          pickState(previousState, keys)
+        );
+      });
+    }
+    const key = keyOrListener;
+    return addSubscription([key], (nextState, previousState) => {
+      listener(nextState[key], previousState[key]);
+    });
+  }, "subscribeState");
+  const useStateValue = /* @__PURE__ */ __name((keyOrKeys) => {
+    if (Array.isArray(keyOrKeys)) {
+      const keys = normalizeKeys(keyOrKeys);
+      let lastState = state;
+      let lastSlice = pickState(state, keys);
+      const getSnapshot = /* @__PURE__ */ __name(() => {
+        if (lastState !== state) {
+          lastState = state;
+          lastSlice = pickState(state, keys);
+        }
+        return lastSlice;
+      }, "getSnapshot");
+      return useSyncExternalStore(
+        (notify) => addSubscription(keys, () => notify()),
+        getSnapshot,
+        getSnapshot
+      );
+    }
+    if (typeof keyOrKeys === "string") {
+      return useSyncExternalStore(
+        (notify) => addSubscription([keyOrKeys], () => notify()),
+        () => state[keyOrKeys],
+        () => state[keyOrKeys]
+      );
+    }
+    return useSyncExternalStore(
+      (notify) => addSubscription(null, () => notify()),
+      () => state,
+      () => state
+    );
+  }, "useStateValue");
+  const store = {
+    use: useStateValue,
+    get: getState,
+    set: setState,
+    replace: replaceState2,
+    reset: /* @__PURE__ */ __name(() => replaceState2(cloneState(initialSnapshot)), "reset"),
+    subscribe: subscribeState
+  };
+  for (const key of Object.keys(initialSnapshot)) {
+    if (RESERVED_STORE_KEYS.has(key)) {
+      throw new Error(
+        `createStore does not allow the reserved key "${String(key)}" in the initial state.`
+      );
+    }
+    const field = /* @__PURE__ */ __name((() => useStateValue(key)), "field");
+    field.get = () => state[key];
+    field.set = (value) => setState(key, value);
+    field.subscribe = (listener) => subscribeState(key, listener);
+    Object.defineProperty(store, key, {
+      configurable: false,
+      enumerable: true,
+      value: field,
+      writable: false
+    });
+  }
+  if (extend) {
+    const methods = extend(store);
+    for (const [name, method] of Object.entries(methods)) {
+      if (name in store) {
+        throw new Error(
+          `createStore cannot attach the method "${name}" because it already exists.`
+        );
+      }
+      Object.defineProperty(store, name, {
+        configurable: false,
+        enumerable: true,
+        value: method,
+        writable: false
+      });
+    }
+  }
+  return store;
+}
+__name(createStore, "createStore");
+
+// src/client/link.tsx
+import { forwardRef, useEffect, useRef as useRef3, useCallback as useCallback3 } from "react";
+import { jsx } from "react/jsx-runtime";
+function isModifierEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+__name(isModifierEvent, "isModifierEvent");
+function isExternalUrl(href) {
+  return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
+}
+__name(isExternalUrl, "isExternalUrl");
+function getRouter() {
+  if (typeof window !== "undefined" && window.__FARM_SPA_ROUTER__) {
+    return window.__FARM_SPA_ROUTER__;
+  }
+  return null;
+}
+__name(getRouter, "getRouter");
+function normalizePrefetch(prefetch2) {
+  if (prefetch2 === false || prefetch2 === "none") {
+    return { intent: false, viewport: false, render: false };
+  }
+  if (prefetch2 === true) {
+    return { intent: true, viewport: true, render: false };
+  }
+  if (prefetch2 === "hover") {
+    return { intent: true, viewport: false, render: false };
+  }
+  if (prefetch2 === "intent") {
+    return { intent: true, viewport: false, render: false };
+  }
+  if (prefetch2 === "viewport") {
+    return { intent: false, viewport: true, render: false };
+  }
+  if (prefetch2 === "render") {
+    return { intent: false, viewport: false, render: true };
+  }
+  return { intent: false, viewport: false, render: false };
+}
+__name(normalizePrefetch, "normalizePrefetch");
+function LinkInner({
+  href,
+  params,
+  query,
+  hash,
+  trailingSlash,
+  prefetch: prefetch2 = true,
+  prefetchDelay = 50,
+  replace = false,
+  scroll = true,
+  viewTransition = false,
+  locale,
+  onClick,
+  target,
+  onMouseEnter,
+  onMouseLeave,
+  onFocus,
+  onBlur,
+  onTouchStart,
+  ...props
+}, ref) {
+  const elementRef = useRef3(null);
+  const intentTimeoutRef = useRef3(null);
+  const hasPrefetched = useRef3(false);
+  const { intent, viewport, render } = normalizePrefetch(prefetch2);
+  const baseHref = resolveLinkHref(href, params, {
+    query,
+    hash,
+    trailingSlash
+  });
+  const resolvedHref = localizeActiveFarmHref(baseHref, locale);
+  const isExternal = isExternalUrl(resolvedHref);
+  const doPrefetch = useCallback3(() => {
+    if (isExternal || hasPrefetched.current) return;
+    const router = getRouter();
+    if (!router) return;
+    hasPrefetched.current = true;
+    router.prefetch(resolvedHref);
+  }, [resolvedHref, isExternal]);
+  useEffect(() => {
+    hasPrefetched.current = false;
+  }, [resolvedHref]);
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element || isExternal) return;
+    const router = getRouter();
+    if (!router) return;
+    if (viewport) {
+      router.observeForPrefetch(element);
+      return () => router.unobserveForPrefetch(element);
+    }
+  }, [resolvedHref, viewport, isExternal]);
+  useEffect(() => {
+    if (!render || isExternal) return;
+    let cancelled = false;
+    let timeoutId = null;
+    const tryRenderPrefetch = /* @__PURE__ */ __name(() => {
+      if (cancelled || hasPrefetched.current) return;
+      const router = getRouter();
+      if (!router) {
+        timeoutId = setTimeout(tryRenderPrefetch, 30);
+        return;
+      }
+      hasPrefetched.current = true;
+      router.prefetch(resolvedHref);
+    }, "tryRenderPrefetch");
+    tryRenderPrefetch();
+    return () => {
+      cancelled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [render, isExternal, resolvedHref]);
+  useEffect(() => {
+    return () => {
+      if (intentTimeoutRef.current) {
+        clearTimeout(intentTimeoutRef.current);
+        intentTimeoutRef.current = null;
+      }
+    };
+  }, []);
+  const cancelIntent = useCallback3(() => {
+    if (intentTimeoutRef.current) {
+      clearTimeout(intentTimeoutRef.current);
+      intentTimeoutRef.current = null;
+    }
+  }, []);
+  const scheduleIntentPrefetch = useCallback3(() => {
+    if (isExternal || !intent || hasPrefetched.current) return;
+    cancelIntent();
+    intentTimeoutRef.current = setTimeout(() => {
+      intentTimeoutRef.current = null;
+      doPrefetch();
+    }, prefetchDelay);
+  }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
+  const handleMouseEnter = useCallback3(
+    (event) => {
+      onMouseEnter?.(event);
+      scheduleIntentPrefetch();
+    },
+    [onMouseEnter, scheduleIntentPrefetch]
+  );
+  const handleMouseLeave = useCallback3(
+    (event) => {
+      onMouseLeave?.(event);
+      cancelIntent();
+    },
+    [onMouseLeave, cancelIntent]
+  );
+  const handleTouchStart = useCallback3(
+    (event) => {
+      onTouchStart?.(event);
+      scheduleIntentPrefetch();
+    },
+    [onTouchStart, scheduleIntentPrefetch]
+  );
+  const handleFocus = useCallback3(
+    (event) => {
+      onFocus?.(event);
+      scheduleIntentPrefetch();
+    },
+    [onFocus, scheduleIntentPrefetch]
+  );
+  const handleBlur = useCallback3(
+    (event) => {
+      onBlur?.(event);
+      cancelIntent();
+    },
+    [onBlur, cancelIntent]
+  );
+  const handleClick = useCallback3(
+    (event) => {
+      onClick?.(event);
+      if (event.defaultPrevented) return;
+      if (isExternal) return;
+      if (target && target !== "_self") return;
+      if (isModifierEvent(event)) return;
+      if (event.button !== 0) return;
+      if (typeof window !== "undefined") {
+        event.preventDefault();
+        if (isFarmLocaleChangeHref(resolvedHref)) {
+          window.location.assign(resolvedHref);
+          return;
+        }
+        const router = getRouter();
+        if (router) {
+          router.navigate(resolvedHref, { replace, scroll, viewTransition });
+        } else {
+          if (replace) window.location.replace(resolvedHref);
+          else window.location.href = resolvedHref;
+        }
+      }
+    },
+    [resolvedHref, replace, scroll, viewTransition, target, isExternal, onClick]
+  );
+  const setRefs = useCallback3(
+    (node) => {
+      elementRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    },
+    [ref]
+  );
+  return /* @__PURE__ */ jsx(
+    "a",
+    {
+      ref: setRefs,
+      href: resolvedHref,
+      target,
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onTouchStart: handleTouchStart,
+      ...props,
+      "data-farm-link": "",
+      "data-replace": replace ? "" : void 0,
+      "data-no-scroll": !scroll ? "" : void 0,
+      "data-view-transition": viewTransition === "auto" ? "auto" : viewTransition ? "true" : void 0
+    }
+  );
+}
+__name(LinkInner, "LinkInner");
+var LinkWithRef = forwardRef(LinkInner);
+LinkWithRef.displayName = "Link";
+var Link = LinkWithRef;
+function resolveLinkHref(href, params, options) {
+  if (isExternalUrl(href)) return href;
+  const { pathname, query, hash } = splitInternalHref(href);
+  const resolvedHref = buildFarmRoutePath(pathname, params, {
+    query: mergeQueryParams(query, options.query),
+    hash: options.hash ?? hash,
+    trailingSlash: options.trailingSlash
+  });
+  return applyPreservedSearchParams(resolvedHref);
+}
+__name(resolveLinkHref, "resolveLinkHref");
+function splitInternalHref(href) {
+  try {
+    const url = new URL(href, "http://farm.local");
+    return {
+      pathname: url.pathname || "/",
+      query: url.searchParams,
+      hash: url.hash ? url.hash.slice(1) : void 0
+    };
+  } catch {
+    const [withoutHash, rawHash] = href.split("#", 2);
+    const [pathname, rawQuery] = withoutHash.split("?", 2);
+    return {
+      pathname: pathname || "/",
+      query: new URLSearchParams(rawQuery || ""),
+      hash: rawHash
+    };
+  }
+}
+__name(splitInternalHref, "splitInternalHref");
+function mergeQueryParams(current, next) {
+  const merged = new URLSearchParams(current);
+  if (next instanceof URLSearchParams) {
+    for (const [key, value] of next.entries()) {
+      merged.append(key, value);
+    }
+  } else if (next) {
+    for (const [key, value] of Object.entries(next)) {
+      const values = Array.isArray(value) ? value : [value];
+      for (const item of values) {
+        if (item == null) continue;
+        merged.append(key, String(item));
+      }
+    }
+  }
+  return merged.toString() ? merged : void 0;
+}
+__name(mergeQueryParams, "mergeQueryParams");
+function applyPreservedSearchParams(href) {
+  if (typeof window === "undefined") return href;
+  const manifest = window.__FARM_MANIFEST__;
+  const routes = manifest?.routes && typeof manifest.routes === "object" ? Object.values(manifest.routes) : [];
+  if (routes.length === 0) return href;
+  const url = new URL(href, window.location.origin);
+  const route = routes.find((candidate) => matchManifestRoute(url.pathname, candidate));
+  const preserve = Array.isArray(route?.search?.preserve) ? route.search.preserve : [];
+  if (preserve.length === 0) return href;
+  const current = new URLSearchParams(window.location.search);
+  let changed = false;
+  for (const key of preserve) {
+    if (url.searchParams.has(key) || !current.has(key)) continue;
+    for (const value of current.getAll(key)) {
+      url.searchParams.append(key, value);
+      changed = true;
+    }
+  }
+  if (!changed) return href;
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+__name(applyPreservedSearchParams, "applyPreservedSearchParams");
+function matchManifestRoute(pathname, route) {
+  if (!route || !Array.isArray(route.segments)) return false;
+  const routeSegments = route.segments;
+  const normalized = pathname === "/" ? "" : pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+  const pathSegments = normalized ? normalized.split("/") : [];
+  const hasCatchAll = routeSegments.some((segment) => segment.isCatchAll);
+  if (!hasCatchAll && pathSegments.length !== routeSegments.length) {
+    return false;
+  }
+  for (let index = 0; index < routeSegments.length; index++) {
+    const routeSegment = routeSegments[index];
+    const pathSegment = pathSegments[index];
+    if (routeSegment.isCatchAll) {
+      return true;
+    }
+    if (pathSegment === void 0) {
+      if (routeSegment.isOptional) continue;
+      return false;
+    }
+    if (!routeSegment.isDynamic && routeSegment.segment !== pathSegment) {
+      return false;
+    }
+  }
+  return pathSegments.length === routeSegments.length || hasCatchAll;
+}
+__name(matchManifestRoute, "matchManifestRoute");
+
+export {
+  useMutation,
+  useFetcher,
+  createStore,
+  Link
+};
+//# sourceMappingURL=chunk-WDU6QXNK.mjs.map