@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-Y4YWHNKU.cjs

@@ -0,0 +1,250 @@
+"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 _chunkI7PUUDGYcjs = require('./chunk-I7PUUDGY.cjs');
+
+
+var _chunkSK35NQKKcjs = require('./chunk-SK35NQKK.cjs');
+
+
+var _chunkH6G5INWMcjs = require('./chunk-H6G5INWM.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client-revalidation.ts
+function attachRevalidationListeners(refresh, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
+  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
+  if (onFocus) window.addEventListener("focus", onFocus);
+  if (onOnline) window.addEventListener("online", onOnline);
+  return () => {
+    if (onFocus) window.removeEventListener("focus", onFocus);
+    if (onOnline) window.removeEventListener("online", onOnline);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, attachRevalidationListeners, "attachRevalidationListeners");
+
+// src/server-query-runtime.ts
+var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
+var serverQueryClientGlobal = globalThis;
+var serverQueryClientState = _nullishCoalesce(serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE], () => ( (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
+  functionIds: /* @__PURE__ */ new WeakMap(),
+  nextFunctionId: 0,
+  active: [],
+  latestOwners: /* @__PURE__ */ new Map(),
+  owners: /* @__PURE__ */ new Set()
+})));
+_nullishCoalesce(serverQueryClientState.latestOwners, () => ( (serverQueryClientState.latestOwners = /* @__PURE__ */ new Map())));
+_nullishCoalesce(serverQueryClientState.owners, () => ( (serverQueryClientState.owners = /* @__PURE__ */ new Set())));
+function isServerQueryOwnerSuperseded(owner, key) {
+  const cache = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, );
+  const resolved = cache.resolveKey(key);
+  for (const superseded of _nullishCoalesce(owner.supersededKeys, () => ( []))) {
+    if (cache.resolveKey(superseded) === resolved) return true;
+  }
+  return false;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isServerQueryOwnerSuperseded, "isServerQueryOwnerSuperseded");
+function claimServerQueryKey(owner, key) {
+  if (isServerQueryOwnerSuperseded(owner, key)) return false;
+  const resolved = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, ).resolveKey(key);
+  for (const older of serverQueryClientState.owners) {
+    if (older === owner) break;
+    older.supersededKeys.add(resolved);
+  }
+  return true;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, claimServerQueryKey, "claimServerQueryKey");
+var RAW_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
+function assertNotRawServerQueryInBrowser(query) {
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  if (!_optionalChain([query, 'optionalAccess', _ => _[RAW_SERVER_QUERY_SYMBOL]])) return;
+  throw new Error(
+    [
+      "useServerQuery received a raw server query implementation in the browser.",
+      "Server query handlers run only on the server. Enable the server-function transform (add @farm.js/plugin/rsc and set experimental.serverActions: true in farm.config.ts) so client imports become server references,",
+      "or call the query from server code / an API route (createAPIClient) instead."
+    ].join("\n")
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertNotRawServerQueryInBrowser, "assertNotRawServerQueryInBrowser");
+function beginFarmServerQueryAction(actionId, args) {
+  const active = serverQueryClientState.active.at(-1);
+  return {
+    actionId,
+    args,
+    provisionalKey: _optionalChain([active, 'optionalAccess', _2 => _2.provisionalKey]),
+    owner: _optionalChain([active, 'optionalAccess', _3 => _3.owner])
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, beginFarmServerQueryAction, "beginFarmServerQueryAction");
+function completeFarmServerQueryAction(invocation, value) {
+  if (!_chunkSK35NQKKcjs.isFarmServerQueryResult.call(void 0, value)) return value;
+  const cache = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, );
+  const metadata = value.__farmServerQuery;
+  if (!shouldApplyFarmServerQueryActionResult(invocation)) {
+    return value.data;
+  }
+  if (invocation.provisionalKey) {
+    cache.alias(invocation.provisionalKey, metadata.key);
+  }
+  const owner = invocation.owner;
+  if (owner && serverQueryClientState.owners.has(owner) && !claimServerQueryKey(owner, metadata.key)) {
+    return value.data;
+  }
+  const invalidated = _optionalChain([invocation, 'access', _4 => _4.owner, 'optionalAccess', _5 => _5.invalidations, 'optionalAccess', _6 => _6.has, 'call', _7 => _7(
+    metadata.key
+  )]);
+  cache.set(metadata.key, {
+    data: value.data,
+    updatedAt: metadata.updatedAt,
+    staleAt: invalidated ? 0 : metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
+    status: "success",
+    error: null,
+    fetching: false,
+    persist: metadata.persist === true ? true : void 0
+  });
+  return value.data;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, completeFarmServerQueryAction, "completeFarmServerQueryAction");
+function shouldApplyFarmServerQueryActionResult(invocation) {
+  if (!invocation.provisionalKey || !invocation.owner) return true;
+  return isCurrentServerQueryOwner(invocation.provisionalKey, invocation.owner);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, shouldApplyFarmServerQueryActionResult, "shouldApplyFarmServerQueryActionResult");
+function isCurrentServerQueryOwner(provisionalKey, owner) {
+  return serverQueryClientState.latestOwners.get(provisionalKey) === owner && !isServerQueryOwnerSuperseded(owner, provisionalKey);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isCurrentServerQueryOwner, "isCurrentServerQueryOwner");
+function createServerQueryCallKey(query, input) {
+  let id = serverQueryClientState.functionIds.get(query);
+  if (!id) {
+    id = ++serverQueryClientState.nextFunctionId;
+    serverQueryClientState.functionIds.set(query, id);
+  }
+  return _chunkH6G5INWMcjs.createFarmCacheKey.call(void 0, ["server-query-call", id, input]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerQueryCallKey, "createServerQueryCallKey");
+async function fetchServerQuery(query, input, options = {}) {
+  const cache = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, );
+  const provisionalKey = createServerQueryCallKey(query, input);
+  const entry = cache.get(provisionalKey);
+  const stale = cache.isStale(provisionalKey);
+  const inflight = cache.getInflight(provisionalKey);
+  if (!options.force && entry && stale && (entry.status !== "pending" || entry.updatedAt !== 0) && entry.status !== "error" && (_nullishCoalesce(options.swr, () => ( true)))) {
+    if (!inflight) {
+      void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+    }
+    return entry.data;
+  }
+  if (inflight && !options.force) return inflight;
+  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
+  return executeServerQuery(query, input, provisionalKey, options);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, fetchServerQuery, "fetchServerQuery");
+function prefetchServerQuery(query, input, options = {}) {
+  return fetchServerQuery(query, input, options);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, prefetchServerQuery, "prefetchServerQuery");
+async function executeServerQuery(query, input, provisionalKey, options) {
+  assertNotRawServerQueryInBrowser(query);
+  const cache = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, );
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight && !options.force) return inflight;
+  const owner = {
+    invalidations: _chunkI7PUUDGYcjs.trackFarmClientCacheInvalidations.call(void 0, cache),
+    supersededKeys: /* @__PURE__ */ new Set()
+  };
+  serverQueryClientState.latestOwners.set(provisionalKey, owner);
+  serverQueryClientState.owners.add(owner);
+  claimServerQueryKey(owner, provisionalKey);
+  const previous = cache.get(provisionalKey);
+  cache.set(provisionalKey, {
+    data: _optionalChain([previous, 'optionalAccess', _8 => _8.data]),
+    updatedAt: _nullishCoalesce(_optionalChain([previous, 'optionalAccess', _9 => _9.updatedAt]), () => ( 0)),
+    staleAt: _nullishCoalesce(_optionalChain([previous, 'optionalAccess', _10 => _10.staleAt]), () => ( 0)),
+    gcAt: _optionalChain([previous, 'optionalAccess', _11 => _11.gcAt]),
+    invalidatedAt: _optionalChain([previous, 'optionalAccess', _12 => _12.invalidatedAt]),
+    status: "pending",
+    error: null,
+    fetching: true
+  });
+  let promise;
+  promise = (async () => {
+    await Promise.resolve();
+    try {
+      serverQueryClientState.active.push({ provisionalKey, owner });
+      let pending;
+      try {
+        pending = query(input);
+      } finally {
+        serverQueryClientState.active.pop();
+      }
+      const data = await pending;
+      const transported = cache.get(provisionalKey);
+      if (isCurrentServerQueryOwner(provisionalKey, owner) && (!transported || transported.fetching)) {
+        const updatedAt = Date.now();
+        cache.set(provisionalKey, {
+          data,
+          updatedAt,
+          staleAt: owner.invalidations.has(provisionalKey) ? 0 : options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (_nullishCoalesce(options.staleTime, () => ( 0))),
+          status: "success",
+          error: null,
+          fetching: false
+        });
+      }
+      return data;
+    } catch (cause) {
+      const error = normalizeServerQueryError(cause);
+      if (isCurrentServerQueryOwner(provisionalKey, owner)) {
+        const current = cache.get(provisionalKey);
+        cache.set(provisionalKey, {
+          data: _optionalChain([current, 'optionalAccess', _13 => _13.data]),
+          updatedAt: _nullishCoalesce(_optionalChain([current, 'optionalAccess', _14 => _14.updatedAt]), () => ( 0)),
+          staleAt: _nullishCoalesce(_optionalChain([current, 'optionalAccess', _15 => _15.staleAt]), () => ( 0)),
+          gcAt: _optionalChain([current, 'optionalAccess', _16 => _16.gcAt]),
+          invalidatedAt: _optionalChain([current, 'optionalAccess', _17 => _17.invalidatedAt]),
+          status: "error",
+          error,
+          fetching: false
+        });
+      }
+      throw error;
+    } finally {
+      const invalidated = isCurrentServerQueryOwner(provisionalKey, owner) && owner.invalidations.has(provisionalKey);
+      owner.invalidations.dispose();
+      serverQueryClientState.owners.delete(owner);
+      owner.supersededKeys.clear();
+      if (cache.getInflight(provisionalKey) === promise) {
+        cache.deleteInflight(provisionalKey);
+      }
+      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
+        serverQueryClientState.latestOwners.delete(provisionalKey);
+      }
+      if (invalidated) cache.invalidate(provisionalKey);
+    }
+  })();
+  cache.setInflight(provisionalKey, promise);
+  return promise;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, executeServerQuery, "executeServerQuery");
+function normalizeServerQueryError(cause) {
+  if (cause instanceof Error) return cause;
+  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
+  error.cause = cause;
+  return error;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeServerQueryError, "normalizeServerQueryError");
+
+
+
+
+
+
+
+
+
+exports.attachRevalidationListeners = attachRevalidationListeners; exports.beginFarmServerQueryAction = beginFarmServerQueryAction; exports.completeFarmServerQueryAction = completeFarmServerQueryAction; exports.shouldApplyFarmServerQueryActionResult = shouldApplyFarmServerQueryActionResult; exports.createServerQueryCallKey = createServerQueryCallKey; exports.fetchServerQuery = fetchServerQuery; exports.prefetchServerQuery = prefetchServerQuery;