@farm.js/core 0.1.0-beta.96 → 0.1.0-beta.97

package/dist/{chunk-SCFX4UTD.mjs → chunk-EHTUKVSW.mjs}

@@ -25,4 +25,4 @@ export {
   createFarmServerQueryResult,
   isFarmServerQueryResult
 };
-//# sourceMappingURL=chunk-SCFX4UTD.mjs.map
+//# sourceMappingURL=chunk-EHTUKVSW.mjs.map

package/dist/chunk-EHTUKVSW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server-query-protocol.ts"],"sourcesContent":["export const FARM_SERVER_QUERY_RESULT_VERSION = 1 as const;\n\nexport type FarmServerQueryResult<TData> = {\n  __farmServerQuery: {\n    version: typeof FARM_SERVER_QUERY_RESULT_VERSION;\n    key: string;\n    staleTime: number | false;\n    updatedAt: number;\n    /** Declared by the query; allows the client persistence adapter to store the entry. */\n    persist?: boolean;\n  };\n  data: TData;\n};\n\nexport function createFarmServerQueryResult<TData>(\n  data: TData,\n  metadata: Omit<FarmServerQueryResult<TData>[\"__farmServerQuery\"], \"version\">,\n): FarmServerQueryResult<TData> {\n  return {\n    __farmServerQuery: {\n      version: FARM_SERVER_QUERY_RESULT_VERSION,\n      ...metadata,\n    },\n    data,\n  };\n}\n\nexport function isFarmServerQueryResult(value: unknown): value is FarmServerQueryResult<unknown> {\n  if (!value || typeof value !== \"object\") return false;\n\n  const metadata = (value as Partial<FarmServerQueryResult<unknown>>).__farmServerQuery;\n  return (\n    metadata?.version === FARM_SERVER_QUERY_RESULT_VERSION &&\n    typeof metadata.key === \"string\" &&\n    (metadata.staleTime === false || typeof metadata.staleTime === \"number\") &&\n    typeof metadata.updatedAt === \"number\" &&\n    \"data\" in value\n  );\n}\n"],"mappings":";;;;;AAAO,IAAM,mCAAmC;AAczC,SAAS,4BACd,MACA,UAC8B;AAC9B,SAAO;AAAA,IACL,mBAAmB;AAAA,MACjB,SAAS;AAAA,MACT,GAAG;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;AAXgB;AAaT,SAAS,wBAAwB,OAAyD;AAC/F,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAEhD,QAAM,WAAY,MAAkD;AACpE,SACE,UAAU,YAAY,oCACtB,OAAO,SAAS,QAAQ,aACvB,SAAS,cAAc,SAAS,OAAO,SAAS,cAAc,aAC/D,OAAO,SAAS,cAAc,YAC9B,UAAU;AAEd;AAXgB;","names":[]}

package/dist/{chunk-LZTGDH3H.mjs → chunk-EPDIF432.mjs}

@@ -1,7 +1,13 @@
 import {
+  invokeMutationWithRetry
+} from "./chunk-6EJHNHH4.mjs";
+import {
+  applyServerFnOptimisticUpdates,
   getAPIRouteRefMetadata,
-  isAPIRouteRef
-} from "./chunk-LKKMI7JG.mjs";
+  isAPIRouteRef,
+  resolveServerFnInvalidateTargets,
+  settleServerFnOptimisticUpdates
+} from "./chunk-IZBX2TEU.mjs";
 import {
   notifyClientObserver
 } from "./chunk-DU3PKDVQ.mjs";
@@ -12,9 +18,18 @@ import {
   isFarmLocaleChangeHref,
   localizeActiveFarmHref
 } from "./chunk-ULD4ENAH.mjs";
+import {
+  getFarmClientDataCache
+} from "./chunk-WMJGA32P.mjs";
 import {
   getFarmTrailingSlashPreference
 } from "./chunk-RCNUKRBF.mjs";
+import {
+  decodeFarmCacheInvalidations,
+  encodeFarmCacheInvalidations,
+  notifyFarmCacheInvalidation,
+  subscribeFarmCacheInvalidation
+} from "./chunk-34IAPZBG.mjs";
 import {
   applyFarmBasePath,
   getFarmBasePath,
@@ -26,6 +41,22 @@ import {
 
 // src/mutation-client.ts
 import { useCallback, useMemo, useRef, useState } from "react";
+
+// src/client-network-status.ts
+function isNavigatorOnline() {
+  if (typeof navigator === "undefined" || typeof navigator.onLine !== "boolean") return true;
+  return navigator.onLine;
+}
+__name(isNavigatorOnline, "isNavigatorOnline");
+function subscribeOnline(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  window.addEventListener("online", listener);
+  return () => window.removeEventListener("online", listener);
+}
+__name(subscribeOnline, "subscribeOnline");
+
+// src/mutation-client.ts
 function useMutation(target, options = {}) {
   return useMutationLifecycle(target, options).mutation;
 }
@@ -38,12 +69,14 @@ function useMutationLifecycle(target, options = {}) {
   const lastResetIdRef = useRef(0);
   const initialState = {
     pendingCount: 0,
+    pausedCount: 0,
     status: "idle",
     data: initialData,
     error: null,
     variables: void 0
   };
   const stateRef = useRef(initialState);
+  const resetWakersRef = useRef(/* @__PURE__ */ new Set());
   const [state, setState] = useState(initialState);
   optionsRef.current = options;
   targetRef.current = target;
@@ -55,6 +88,31 @@ function useMutationLifecycle(target, options = {}) {
     },
     []
   );
+  const waitForReconnect = useCallback(
+    async (requestId) => {
+      while (!isNavigatorOnline()) {
+        if (requestId < lastResetIdRef.current) return;
+        setMutationState((current) => ({ ...current, pausedCount: current.pausedCount + 1 }));
+        try {
+          await new Promise((resolve) => {
+            const wake = /* @__PURE__ */ __name(() => {
+              unsubscribe();
+              resetWakersRef.current.delete(wake);
+              resolve();
+            }, "wake");
+            const unsubscribe = subscribeOnline(wake);
+            resetWakersRef.current.add(wake);
+          });
+        } finally {
+          setMutationState((current) => ({
+            ...current,
+            pausedCount: Math.max(0, current.pausedCount - 1)
+          }));
+        }
+      }
+    },
+    [setMutationState]
+  );
   const mutatePreparedAsync = useCallback(
     async (prepare) => {
       const requestId = ++requestIdRef.current;
@@ -77,17 +135,49 @@ function useMutationLifecycle(target, options = {}) {
         if (requestId !== requestIdRef.current) return { ...current, pendingCount };
         return {
           pendingCount,
+          pausedCount: current.pausedCount,
           status: "pending",
           data: hasOptimisticData ? optimisticData : currentOptions.resetOnMutate === false ? current.data : null,
           error: null,
           variables
         };
       });
+      const mutationTarget = targetRef.current;
+      const isAPITarget = isAPIRouteRef(mutationTarget);
+      const sharedOptimistic = !preparationFailed && !isAPITarget ? currentOptions.request?.optimistic : void 0;
+      const sharedSnapshots = sharedOptimistic?.update?.length ? applyServerFnOptimisticUpdates(sharedOptimistic.update) : [];
       try {
         if (preparationFailed) throw preparationError;
-        const mutationTarget = targetRef.current;
-        const rawResult = isAPIRouteRef(mutationTarget) ? await mutationTarget(variables, currentOptions.request) : await mutationTarget(variables);
-        const data = unwrapMutationResult(rawResult, isAPIRouteRef(mutationTarget));
+        let data;
+        while (true) {
+          if (currentOptions.networkMode === "online") {
+            await waitForReconnect(requestId);
+            if (requestId < lastResetIdRef.current) {
+              throw new Error("Mutation reset while waiting for reconnection");
+            }
+          }
+          try {
+            const rawResult = isAPITarget ? await mutationTarget(variables, currentOptions.request) : await invokeMutationWithRetry(
+              () => targetRef.current(variables),
+              currentOptions.request?.retry,
+              // A reset disowns this submission; stop scheduling retries then.
+              () => requestId >= lastResetIdRef.current
+            );
+            data = unwrapMutationResult(rawResult, isAPITarget);
+            break;
+          } catch (cause) {
+            if (currentOptions.networkMode === "online" && !isNavigatorOnline() && requestId >= lastResetIdRef.current) {
+              continue;
+            }
+            throw cause;
+          }
+        }
+        settleServerFnOptimisticUpdates(sharedSnapshots, "commit");
+        if (!isAPITarget && currentOptions.request?.invalidate) {
+          for (const key of resolveServerFnInvalidateTargets(currentOptions.request.invalidate)) {
+            notifyFarmCacheInvalidation(key);
+          }
+        }
         const isLatestRequest = requestId === requestIdRef.current;
         setMutationState((current) => {
           if (requestId < lastResetIdRef.current) return current;
@@ -100,6 +190,7 @@ function useMutationLifecycle(target, options = {}) {
           }
           return {
             pendingCount,
+            pausedCount: current.pausedCount,
             status: "success",
             data,
             error: null,
@@ -118,6 +209,10 @@ function useMutationLifecycle(target, options = {}) {
         }
         return data;
       } catch (cause) {
+        settleServerFnOptimisticUpdates(
+          sharedSnapshots,
+          sharedOptimistic?.rollbackOnError ? "rollback" : "invalidate"
+        );
         const error = normalizeMutationError(cause);
         const isLatestRequest = requestId === requestIdRef.current;
         setMutationState((current) => {
@@ -131,6 +226,7 @@ function useMutationLifecycle(target, options = {}) {
           }
           return {
             pendingCount,
+            pausedCount: current.pausedCount,
             status: "error",
             data: hasOptimisticData && currentOptions.rollbackOnError ? previousData : currentOptions.resetOnMutate === false ? current.data : null,
             error,
@@ -150,7 +246,7 @@ function useMutationLifecycle(target, options = {}) {
         throw error;
       }
     },
-    [setMutationState]
+    [setMutationState, waitForReconnect]
   );
   const mutateAsync = useCallback(
     (variables) => mutatePreparedAsync(() => variables),
@@ -167,15 +263,20 @@ function useMutationLifecycle(target, options = {}) {
     lastResetIdRef.current = ++requestIdRef.current;
     setMutationState({
       pendingCount: 0,
+      pausedCount: 0,
       status: "idle",
       data: optionsRef.current.initialData ?? null,
       error: null,
       variables: void 0
     });
+    const wakers = Array.from(resetWakersRef.current);
+    resetWakersRef.current.clear();
+    for (const wake of wakers) wake();
   }, [setMutationState]);
   const mutation = useMemo(
     () => ({
       pending: state.pendingCount > 0,
+      paused: state.pausedCount > 0,
       status: state.status,
       data: state.data,
       error: state.error,
@@ -190,6 +291,7 @@ function useMutationLifecycle(target, options = {}) {
       reset,
       state.data,
       state.error,
+      state.pausedCount,
       state.pendingCount,
       state.status,
       state.variables
@@ -315,6 +417,7 @@ function useFetcher(target, options = {}) {
       state: mutation.pending ? "submitting" : "idle",
       status: mutation.status,
       pending: mutation.pending,
+      paused: mutation.paused,
       data: mutation.data,
       error: mutation.error,
       variables: mutation.variables,
@@ -329,6 +432,7 @@ function useFetcher(target, options = {}) {
       formData,
       mutation.data,
       mutation.error,
+      mutation.paused,
       mutation.pending,
       mutation.status,
       mutation.variables,
@@ -347,9 +451,18 @@ function mapFetcherFormData(target, formData, options) {
   if (!isAPIRouteRef(target)) {
     return formData;
   }
-  const values = formDataToObject(formData);
   const method = getAPIRouteRefMetadata(target)?.method;
-  return method === "GET" || method === "HEAD" ? { query: values } : { body: values };
+  const query = method === "GET" || method === "HEAD";
+  const encoding = context.submitter?.getAttribute("formenctype") ?? context.form?.enctype;
+  if (!query && (encoding?.toLowerCase() === "multipart/form-data" || Array.from(formData.values()).some((value) => typeof value !== "string"))) {
+    const body = new FormData();
+    for (const [key, value] of formData) {
+      if (!isUnsafeFormKey(key)) body.append(key, value);
+    }
+    return { body };
+  }
+  const values = formDataToObject(formData);
+  return query ? { query: values } : { body: values };
 }
 __name(mapFetcherFormData, "mapFetcherFormData");
 function resolveFetcherFormAction(target, metadata) {
@@ -361,7 +474,7 @@ __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;
+    if (isUnsafeFormKey(key)) continue;
     const current = output[key];
     if (current === void 0) {
       output[key] = value;
@@ -374,6 +487,10 @@ function formDataToObject(formData) {
   return output;
 }
 __name(formDataToObject, "formDataToObject");
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+__name(isUnsafeFormKey, "isUnsafeFormKey");
 function createSubmitterFormData(form, submitter) {
   try {
     return new FormData(form, submitter);
@@ -403,6 +520,296 @@ function isFormData(value) {
 }
 __name(isFormData, "isFormData");
 
+// src/cache-invalidation-broadcast.ts
+var FARM_CACHE_INVALIDATION_CHANNEL = "farm:cache-invalidation";
+var activeBridge;
+function enableCrossTabCacheInvalidation(options = {}) {
+  if (typeof BroadcastChannel !== "function") return () => {
+  };
+  const channelName = options.channelName ?? FARM_CACHE_INVALIDATION_CHANNEL;
+  if (activeBridge) {
+    if (activeBridge.channelName !== channelName) {
+      throw new Error(
+        `Cross-tab cache invalidation is already enabled on channel "${activeBridge.channelName}".`
+      );
+    }
+    activeBridge.refCount += 1;
+  } else {
+    activeBridge = createBridge(channelName);
+  }
+  let disposed = false;
+  return () => {
+    if (disposed || !activeBridge) return;
+    disposed = true;
+    activeBridge.refCount -= 1;
+    if (activeBridge.refCount === 0) {
+      activeBridge.teardown();
+      activeBridge = void 0;
+    }
+  };
+}
+__name(enableCrossTabCacheInvalidation, "enableCrossTabCacheInvalidation");
+function createBridge(channelName) {
+  const channel = new BroadcastChannel(channelName);
+  let applyingRemote = false;
+  let pending = [];
+  let flushScheduled = false;
+  let closed = false;
+  const flush = /* @__PURE__ */ __name(() => {
+    flushScheduled = false;
+    if (closed || pending.length === 0) return;
+    const encoded = encodeFarmCacheInvalidations(pending);
+    pending = [];
+    if (encoded !== null) channel.postMessage(encoded);
+  }, "flush");
+  const unsubscribe = subscribeFarmCacheInvalidation((key) => {
+    if (applyingRemote || closed) return;
+    pending.push(key);
+    if (!flushScheduled) {
+      flushScheduled = true;
+      queueMicrotask(flush);
+    }
+  });
+  channel.onmessage = (event) => {
+    const keys = decodeFarmCacheInvalidations(
+      typeof event.data === "string" ? event.data : void 0
+    );
+    if (keys.length === 0) return;
+    applyingRemote = true;
+    try {
+      for (const key of keys) notifyFarmCacheInvalidation(key);
+    } finally {
+      applyingRemote = false;
+    }
+  };
+  return {
+    channelName,
+    refCount: 1,
+    teardown() {
+      closed = true;
+      pending = [];
+      unsubscribe();
+      channel.onmessage = null;
+      channel.close();
+    }
+  };
+}
+__name(createBridge, "createBridge");
+
+// src/client-cache-persistence.ts
+var FARM_CLIENT_CACHE_PERSIST_VERSION = "1";
+function defineClientCacheAdapter(adapter) {
+  for (const method of ["keys", "get", "set", "delete", "clear"]) {
+    if (typeof adapter?.[method] !== "function") {
+      throw new TypeError(
+        `defineClientCacheAdapter expects a "${method}" method. Implement keys/get/set/delete/clear over your storage.`
+      );
+    }
+  }
+  return adapter;
+}
+__name(defineClientCacheAdapter, "defineClientCacheAdapter");
+function storageClientCacheAdapter(storage, options = {}) {
+  if (!storage || typeof storage.getItem !== "function" || typeof storage.setItem !== "function" || typeof storage.removeItem !== "function") {
+    throw new TypeError("storageClientCacheAdapter expects a compatible key-value client.");
+  }
+  const base = options.base ?? "farm-client-cache";
+  const entryKey = /* @__PURE__ */ __name((key) => `${base}:${key}`, "entryKey");
+  const enumerate = storage.getKeys?.bind(storage) ?? storage.keys?.bind(storage);
+  return {
+    async keys() {
+      if (!enumerate) return [];
+      const keys = await enumerate(base);
+      const prefix = `${base}:`;
+      return keys.filter((key) => key.startsWith(prefix)).map((key) => key.slice(prefix.length));
+    },
+    async get(key) {
+      return await storage.getItem(entryKey(key)) ?? null;
+    },
+    async set(key, entry) {
+      await storage.setItem(entryKey(key), entry);
+    },
+    async delete(key) {
+      await storage.removeItem(entryKey(key));
+    },
+    async clear() {
+      if (storage.clear) {
+        await storage.clear(base);
+        return;
+      }
+      if (!enumerate) return;
+      const prefix = `${base}:`;
+      for (const key of await enumerate(base)) {
+        if (key.startsWith(prefix)) await storage.removeItem(key);
+      }
+    }
+  };
+}
+__name(storageClientCacheAdapter, "storageClientCacheAdapter");
+var activeEngine;
+function reportPersistenceFailure(error) {
+  const report = typeof reportError === "function" ? reportError : console.error;
+  if (error instanceof Error) {
+    report(error);
+    return;
+  }
+  const normalized = new Error("Client cache persistence failed");
+  normalized.cause = error;
+  report(normalized);
+}
+__name(reportPersistenceFailure, "reportPersistenceFailure");
+function disableEngine(engine, error) {
+  if (engine.disabled) return;
+  engine.disabled = true;
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  if (engine.flushTimer !== void 0) {
+    clearTimeout(engine.flushTimer);
+    engine.flushTimer = void 0;
+  }
+  reportPersistenceFailure(error);
+}
+__name(disableEngine, "disableEngine");
+function scheduleFlush(engine) {
+  if (engine.disabled || engine.flushTimer !== void 0) return;
+  const timer = setTimeout(() => {
+    engine.flushTimer = void 0;
+    void flushEngine(engine);
+  }, engine.flushDelayMs);
+  timer.unref?.();
+  engine.flushTimer = timer;
+}
+__name(scheduleFlush, "scheduleFlush");
+async function flushEngine(engine) {
+  if (engine.disabled) return;
+  const sets = Array.from(engine.pendingSets.entries());
+  const deletes = Array.from(engine.pendingDeletes);
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  try {
+    if (sets.length > 0) {
+      if (engine.adapter.setMany) await engine.adapter.setMany(sets);
+      else for (const [key, entry] of sets) await engine.adapter.set(key, entry);
+    }
+    for (const key of deletes) await engine.adapter.delete(key);
+  } catch (error) {
+    disableEngine(engine, error);
+  }
+}
+__name(flushEngine, "flushEngine");
+async function hydrateEngine(engine) {
+  const now = Date.now();
+  const keys = await engine.adapter.keys();
+  if (keys.length === 0) return;
+  const persisted = engine.adapter.getMany ? await engine.adapter.getMany(keys) : await Promise.all(keys.map((key) => engine.adapter.get(key)));
+  engine.hydrating = true;
+  try {
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      const entry = persisted[index];
+      if (engine.disabled) return;
+      if (!entry || entry.version !== engine.version || entry.gcAt !== void 0 && now >= entry.gcAt) {
+        engine.pendingDeletes.add(key);
+        continue;
+      }
+      if (engine.cache.get(key, now)) continue;
+      engine.cache.set(key, {
+        data: entry.data,
+        updatedAt: entry.updatedAt,
+        staleAt: 0,
+        gcAt: entry.gcAt,
+        status: "success",
+        error: null,
+        persist: true
+      });
+    }
+  } finally {
+    engine.hydrating = false;
+  }
+  if (engine.pendingDeletes.size > 0) scheduleFlush(engine);
+}
+__name(hydrateEngine, "hydrateEngine");
+function createSink(engine) {
+  return {
+    onSet(key, entry) {
+      if (engine.disabled || engine.hydrating) return;
+      if (!entry.persist || entry.fetching || entry.error || entry.status === "pending") return;
+      if (engine.persistKey && !engine.persistKey(key)) return;
+      engine.pendingDeletes.delete(key);
+      engine.pendingSets.set(key, {
+        data: entry.data,
+        updatedAt: entry.updatedAt,
+        staleAt: entry.staleAt,
+        gcAt: entry.gcAt,
+        version: engine.version
+      });
+      scheduleFlush(engine);
+    },
+    onDelete(key) {
+      if (engine.disabled) return;
+      engine.pendingSets.delete(key);
+      engine.pendingDeletes.add(key);
+      scheduleFlush(engine);
+    },
+    onClear() {
+      if (engine.disabled) return;
+      engine.pendingSets.clear();
+      engine.pendingDeletes.clear();
+      void engine.adapter.clear().catch((error) => disableEngine(engine, error));
+    }
+  };
+}
+__name(createSink, "createSink");
+function initPersistedClientCache(adapter, options = {}) {
+  defineClientCacheAdapter(adapter);
+  disposePersistedClientCache();
+  const engine = {
+    adapter,
+    cache: getFarmClientDataCache(),
+    version: options.version ? `${FARM_CLIENT_CACHE_PERSIST_VERSION}:${options.version}` : FARM_CLIENT_CACHE_PERSIST_VERSION,
+    persistKey: options.persistKey,
+    flushDelayMs: options.flushDelayMs ?? 300,
+    pendingSets: /* @__PURE__ */ new Map(),
+    pendingDeletes: /* @__PURE__ */ new Set(),
+    flushTimer: void 0,
+    hydrating: false,
+    disabled: false
+  };
+  activeEngine = engine;
+  engine.cache.attachPersistence(createSink(engine));
+  void hydrateEngine(engine).catch((error) => disableEngine(engine, error));
+  return () => {
+    if (activeEngine !== engine) return;
+    disposePersistedClientCache();
+  };
+}
+__name(initPersistedClientCache, "initPersistedClientCache");
+function disposePersistedClientCache() {
+  const engine = activeEngine;
+  if (!engine) return;
+  activeEngine = void 0;
+  engine.cache.attachPersistence(void 0);
+  if (engine.flushTimer !== void 0) {
+    clearTimeout(engine.flushTimer);
+    engine.flushTimer = void 0;
+  }
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+}
+__name(disposePersistedClientCache, "disposePersistedClientCache");
+async function clearPersistedCache() {
+  const engine = activeEngine;
+  if (!engine) return;
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  try {
+    await engine.adapter.clear();
+  } catch (error) {
+    disableEngine(engine, error);
+  }
+}
+__name(clearPersistedCache, "clearPersistedCache");
+
 // src/store.ts
 import { useSyncExternalStore } from "react";
 var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
@@ -966,7 +1373,14 @@ export {
   useMutation,
   FetcherInputError,
   useFetcher,
+  FARM_CACHE_INVALIDATION_CHANNEL,
+  enableCrossTabCacheInvalidation,
+  FARM_CLIENT_CACHE_PERSIST_VERSION,
+  defineClientCacheAdapter,
+  storageClientCacheAdapter,
+  initPersistedClientCache,
+  clearPersistedCache,
   createStore,
   Link
 };
-//# sourceMappingURL=chunk-LZTGDH3H.mjs.map
+//# sourceMappingURL=chunk-EPDIF432.mjs.map