@sanity/sdk 2.18.0 → 3.0.0-rc.1

package/dist/_chunks-es/createGroqSearchFilter.js

@@ -1,6 +1,8 @@
-import { createImageUrlBuilder } from "@sanity/image-url";
-import { Observable, map, distinctUntilChanged, shareReplay, skip, defer, finalize, filter, exhaustMap, timer, switchMap, takeWhile, catchError, EMPTY, fromEvent, retry, BehaviorSubject, combineLatest, startWith, tap, NEVER, first, firstValueFrom, race, pairwise, mergeMap, groupBy, of, share } from "rxjs";
 import { createClient, CorsOriginError, DisconnectError, ConnectionFailedError } from "@sanity/client";
+import { createImageUrlBuilder } from "@sanity/image-url";
+import "groq";
+import { Observable, map, distinctUntilChanged, shareReplay, skip, defer, finalize, filter, exhaustMap, timer, switchMap, takeWhile, catchError, EMPTY, fromEvent, retry, BehaviorSubject, combineLatest, startWith, tap, pairwise, mergeMap, groupBy, of, share, NEVER, first, firstValueFrom, race, Subscription } from "rxjs";
+import "@sanity/types";
 import { devtools } from "zustand/middleware";
 import { createStore } from "zustand/vanilla";
 import { createSelector } from "reselect";
@@ -1262,9 +1264,17 @@ const ARCHIVED_RELEASE_STATES = ["archived", "published"], STABLE_EMPTY_RELEASES
   // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
   _boundGetPerspectiveState(instance, ...rest.length ? rest : [{}])
 );
+function unref(timer2) {
+  const t = timer2;
+  typeof t == "object" && t !== null && "unref" in t && typeof t.unref == "function" && t.unref();
+}
 function setCleanupTimeout(fn, delay) {
-  const timer2 = setTimeout(fn, delay), t = timer2;
-  return typeof t == "object" && t !== null && "unref" in t && typeof t.unref == "function" && t.unref(), timer2;
+  const timer2 = setTimeout(fn, delay);
+  return unref(timer2), timer2;
+}
+function setCleanupInterval(fn, delay) {
+  const timer2 = setInterval(fn, delay);
+  return unref(timer2), timer2;
 }
 const QUERY_STATE_CLEAR_DELAY = 1e3, QUERY_STORE_API_VERSION = "v2025-05-06", QUERY_STORE_DEFAULT_PERSPECTIVE = "drafts", setQueryError = (key, error) => (prev) => {
   const prevQuery = prev.queries[key];
@@ -1456,7 +1466,273 @@ const _resolveQuery = bindActionByResource(
     };
     return promise.then(releaseSubscriber, releaseSubscriber), promise;
   }
-), API_VERSION = "vX", PROJECT_API_VERSION = "2025-07-18", USERS_STATE_CLEAR_DELAY = 5e3, DEFAULT_USERS_BATCH_SIZE = 100, getUsersKey = (instance, {
+), DEFAULT_STALE_TIME = 3e4, DEFAULT_GC_TIME = 3e5, definitions = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map(), gcTimers = /* @__PURE__ */ new Map(), intervalTimers = /* @__PURE__ */ new Map(), snapshotCache = /* @__PURE__ */ new WeakMap(), PENDING_SNAPSHOT = {
+  status: "pending",
+  data: void 0,
+  error: void 0,
+  isFetching: !1,
+  dataUpdatedAt: void 0
+}, entryKey = (fetcherName, rawKey) => `${fetcherName}:${rawKey}`, computeTags = (def, data, params) => typeof def.tags == "function" ? def.tags(data, ...params) : def.tags ?? [], isUpdaterFn = (updater) => typeof updater == "function", applyUpdater = (updater, current) => isUpdaterFn(updater) ? updater(current) : updater, needsFetch = (entry, def) => entry.isFetching ? !1 : entry.status !== "success" ? !0 : entry.forcedStale || Date.now() - (entry.dataUpdatedAt ?? 0) >= (def.staleTime ?? DEFAULT_STALE_TIME), asTyped = (entry) => entry, toSnapshot = (entry) => {
+  if (!entry) return PENDING_SNAPSHOT;
+  const cached = snapshotCache.get(entry);
+  if (cached) return cached;
+  let snapshot;
+  return entry.status === "success" ? snapshot = {
+    status: "success",
+    data: entry.data,
+    error: entry.error,
+    isFetching: entry.isFetching,
+    dataUpdatedAt: entry.dataUpdatedAt
+  } : entry.status === "error" ? snapshot = {
+    status: "error",
+    data: void 0,
+    error: entry.error,
+    isFetching: entry.isFetching,
+    dataUpdatedAt: void 0
+  } : snapshot = {
+    status: "pending",
+    data: void 0,
+    error: void 0,
+    isFetching: entry.isFetching,
+    dataUpdatedAt: void 0
+  }, snapshotCache.set(entry, snapshot), snapshot;
+}, cacheStore = {
+  name: "FetcherCache",
+  getInitialState: () => ({ entries: {} }),
+  initialize: () => () => {
+    for (const timer2 of gcTimers.values()) clearTimeout(timer2);
+    for (const timer2 of intervalTimers.values()) clearInterval(timer2);
+    for (const fetch of inflight.values()) fetch.sub.unsubscribe();
+    gcTimers.clear(), intervalTimers.clear(), inflight.clear();
+  }
+}, updateEntry = (state, key, actionName, updater) => {
+  state.set(actionName, (prev) => {
+    const next = updater(prev.entries[key]);
+    if (next === prev.entries[key]) return prev;
+    const entries = { ...prev.entries };
+    return next === void 0 ? delete entries[key] : entries[key] = next, { entries };
+  });
+}, baseEntry = (def, key, instance, params) => {
+  const seeded = def.initialData?.(instance, ...params);
+  return seeded ? {
+    fetcherName: def.name,
+    key,
+    params,
+    instance,
+    status: "success",
+    data: seeded.data,
+    error: void 0,
+    dataUpdatedAt: seeded.dataUpdatedAt,
+    isFetching: !1,
+    version: 0,
+    forcedStale: !1,
+    tags: computeTags(def, seeded.data, params),
+    subscriptions: 0
+  } : {
+    fetcherName: def.name,
+    key,
+    params,
+    instance,
+    status: "pending",
+    data: void 0,
+    error: void 0,
+    dataUpdatedAt: void 0,
+    isFetching: !1,
+    version: 0,
+    forcedStale: !1,
+    tags: [],
+    subscriptions: 0
+  };
+}, startFetch = (state, def, instance, params, force) => {
+  const key = entryKey(def.name, def.getKey(instance, ...params)), existing = inflight.get(key);
+  if (existing && !force) return existing.promise;
+  existing && (existing.sub.unsubscribe(), inflight.delete(key)), updateEntry(state, key, "fetchStart", (prev) => ({
+    ...prev ?? baseEntry(def, key, instance, params),
+    isFetching: !0
+  }));
+  const startVersion = state.get().entries[key]?.version ?? 0;
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res, reject = rej;
+  });
+  existing && promise.then(existing.resolve, existing.reject);
+  const sub = new Subscription();
+  return inflight.set(key, { sub, promise, resolve, reject, startVersion }), sub.add(
+    def.fetch(instance)(...params).subscribe({
+      next: (data) => {
+        const current = state.get().entries[key];
+        if (current && current.version !== startVersion) {
+          inflight.delete(key), current.isFetching && updateEntry(
+            state,
+            key,
+            "fetchDiscard",
+            (prev) => prev && { ...prev, isFetching: !1 }
+          ), resolve(current.data), sub.unsubscribe();
+          return;
+        }
+        updateEntry(state, key, "fetchSuccess", (prev) => ({
+          ...prev ?? baseEntry(def, key, instance, params),
+          status: "success",
+          data,
+          error: void 0,
+          dataUpdatedAt: Date.now(),
+          isFetching: !1,
+          forcedStale: !1,
+          tags: computeTags(def, data, params)
+        })), resolve(data);
+      },
+      error: (error) => {
+        updateEntry(state, key, "fetchError", (prev) => prev && (prev.status === "success" ? { ...prev, error, isFetching: !1 } : { ...prev, status: "error", error, isFetching: !1 })), inflight.delete(key), reject(error);
+      },
+      complete: () => {
+        inflight.delete(key), state.get().entries[key]?.isFetching && updateEntry(state, key, "fetchSettle", (prev) => prev && { ...prev, isFetching: !1 });
+      }
+    })
+  ), promise;
+}, detach = (promise) => {
+  promise.catch(() => {
+  });
+}, markStale = (state, key) => updateEntry(state, key, "markStale", (prev) => prev && { ...prev, forcedStale: !0 }), startInterval = (state, def, instance, params, key) => {
+  if (!def.refetchInterval || intervalTimers.has(key)) return;
+  const timer2 = setCleanupInterval(() => {
+    if (typeof document < "u" && document.hidden) return;
+    const entry = state.get().entries[key];
+    entry && entry.subscriptions > 0 && detach(startFetch(state, def, instance, params, !0));
+  }, def.refetchInterval);
+  intervalTimers.set(key, timer2);
+}, scheduleGc = (state, def, key) => {
+  if (gcTimers.has(key)) return;
+  const entry = state.get().entries[key];
+  if (!entry || entry.subscriptions > 0) return;
+  const timer2 = setCleanupTimeout(() => {
+    gcTimers.delete(key);
+    const fetch = inflight.get(key);
+    fetch && (fetch.sub.unsubscribe(), inflight.delete(key)), updateEntry(state, key, "gc", () => {
+    });
+  }, def.gcTime ?? DEFAULT_GC_TIME);
+  gcTimers.set(key, timer2);
+}, invalidateByTags = bindActionGlobally(
+  cacheStore,
+  ({ state }, targets) => {
+    const refetches = [];
+    for (const [key, entry] of Object.entries(state.get().entries)) {
+      if (!entry.tags.some(
+        (tag) => targets.some(
+          (target) => tag.type === target.type && (target.id === void 0 || tag.id === target.id)
+        )
+      ) || (markStale(state, key), entry.subscriptions <= 0)) continue;
+      const def = definitions.get(entry.fetcherName);
+      def && refetches.push(
+        startFetch(state, def, entry.instance, entry.params, !0).catch(() => {
+        })
+      );
+    }
+    return Promise.all(refetches).then(() => {
+    });
+  }
+);
+function defineFetcher(definition) {
+  const def = definition;
+  definitions.set(definition.name, def);
+  const getState = bindActionGlobally(
+    cacheStore,
+    createStateSourceAction({
+      selector: ({ state, instance }, ...params) => {
+        const key = entryKey(def.name, def.getKey(instance, ...params)), entry = state.entries[key];
+        return toSnapshot(entry && asTyped(entry));
+      },
+      onSubscribe: ({ state, instance }, ...params) => {
+        const key = entryKey(def.name, def.getKey(instance, ...params)), pendingGc = gcTimers.get(key);
+        return pendingGc && (clearTimeout(pendingGc), gcTimers.delete(key)), updateEntry(state, key, "subscribe", (prev) => ({
+          ...prev ?? baseEntry(def, key, instance, params),
+          instance,
+          subscriptions: (prev?.subscriptions ?? 0) + 1
+        })), startInterval(state, def, instance, params, key), queueMicrotask(() => {
+          const entry = state.get().entries[key];
+          entry && entry.subscriptions > 0 && needsFetch(entry, def) && detach(startFetch(state, def, instance, params, !1));
+        }), () => {
+          updateEntry(
+            state,
+            key,
+            "unsubscribe",
+            (prev) => prev && { ...prev, subscriptions: Math.max(0, prev.subscriptions - 1) }
+          );
+          const entry = state.get().entries[key];
+          if (!entry || entry.subscriptions > 0) return;
+          const interval = intervalTimers.get(key);
+          interval && (clearInterval(interval), intervalTimers.delete(key)), scheduleGc(state, def, key);
+        };
+      }
+    })
+  ), resolveState = (instance, ...params) => firstValueFrom(
+    getState(instance, ...params).observable.pipe(
+      filter(
+        (snapshot) => snapshot.status !== "pending"
+      ),
+      map((snapshot) => {
+        if (snapshot.status === "error") throw snapshot.error;
+        return snapshot.data;
+      })
+    )
+  ), invalidate = bindActionGlobally(
+    cacheStore,
+    ({ state, instance }, ...params) => {
+      const key = entryKey(def.name, def.getKey(instance, ...params));
+      markStale(state, key);
+      const entry = state.get().entries[key];
+      entry && entry.subscriptions > 0 && detach(startFetch(state, def, instance, params, !0));
+    }
+  ), invalidateAll = bindActionGlobally(cacheStore, ({ state }) => {
+    const prefix = `${def.name}:`;
+    for (const [key, entry] of Object.entries(state.get().entries))
+      key.startsWith(prefix) && (markStale(state, key), entry.subscriptions > 0 && detach(startFetch(state, def, entry.instance, entry.params, !0)));
+  }), refetch = bindActionGlobally(
+    cacheStore,
+    ({ state, instance }, ...params) => {
+      const key = entryKey(def.name, def.getKey(instance, ...params)), promise = startFetch(state, def, instance, params, !0);
+      return scheduleGc(state, def, key), promise;
+    }
+  ), setData = bindActionGlobally(
+    cacheStore,
+    ({ state, instance }, params, updater) => {
+      const key = entryKey(def.name, def.getKey(instance, ...params));
+      let previous;
+      return updateEntry(state, key, "setData", (prev) => {
+        previous = prev;
+        const from = asTyped(prev ?? baseEntry(def, key, instance, params)), nextData = applyUpdater(updater, from.data);
+        return {
+          ...from,
+          status: "success",
+          data: nextData,
+          dataUpdatedAt: from.dataUpdatedAt ?? Date.now(),
+          version: from.version + 1,
+          tags: computeTags(def, nextData, params)
+        };
+      }), scheduleGc(state, def, key), { undo: () => updateEntry(state, key, "undoSetData", () => previous) };
+    }
+  );
+  return { getState, resolveState, invalidate, invalidateAll, refetch, setData };
+}
+function defineMutation(definition) {
+  return (instance, input) => {
+    const undos = [], write = (fetcher, params, updater) => {
+      undos.push(fetcher.setData(instance, params, updater).undo);
+    };
+    return definition.onMutate?.(write, input), firstValueFrom(definition.mutationFn(instance)(input)).then(
+      (result) => {
+        definition.onSuccess?.(write, result, input);
+        const targets = typeof definition.invalidates == "function" ? definition.invalidates(result, input) : definition.invalidates ?? [], invalidated = targets.length ? invalidateByTags(instance, targets) : Promise.resolve();
+        return { data: result, invalidated };
+      },
+      (error) => {
+        for (let i = undos.length - 1; i >= 0; i--) undos[i]();
+        throw error;
+      }
+    );
+  };
+}
+var version = "3.0.0-rc.1";
+const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`, API_VERSION = "vX", PROJECT_API_VERSION = "2025-07-18", USERS_STATE_CLEAR_DELAY = 5e3, DEFAULT_USERS_BATCH_SIZE = 100, getUsersKey = (instance, {
   resourceType,
   organizationId,
   batchSize = DEFAULT_USERS_BATCH_SIZE,
@@ -1516,6 +1792,7 @@ function createGroqSearchFilter(query) {
 export {
   API_VERSION,
   AuthStateType,
+  CORE_SDK_VERSION,
   DEFAULT_API_VERSION$1 as DEFAULT_API_VERSION,
   PREVIEW_PROJECTION,
   PROJECT_API_VERSION,
@@ -1534,6 +1811,8 @@ export {
   createLoggedInAuthState,
   createLogger,
   createStateSourceAction,
+  defineFetcher,
+  defineMutation,
   defineStore,
   getActiveReleasesState,
   getAllReleasesState,
@@ -1549,7 +1828,6 @@ export {
   getCurrentUserState,
   getDashboardOrganizationId,
   getDefaultLocation,
-  getEnv,
   getIsInDashboardState,
   getLoginUrlState,
   getPerspectiveState,