@sanity/client 6.27.2 → 6.27.3-canary.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "6.27.2",
+  "version": "6.27.3-canary.0",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "keywords": [
     "sanity",
@@ -130,7 +130,7 @@
     "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@sanity/client-latest": "npm:@sanity/client@latest",
-    "@sanity/pkg-utils": "^7.0.3",
+    "@sanity/pkg-utils": "^7.0.4",
     "@types/json-diff": "^1.0.3",
     "@types/node": "^22.9.0",
     "@typescript-eslint/eslint-plugin": "^8.22.0",
@@ -153,7 +153,7 @@
     "prettier": "^3.4.2",
     "prettier-plugin-packagejson": "^2.5.8",
     "rimraf": "^5.0.7",
-    "rollup": "^4.32.0",
+    "rollup": "^4.32.1",
     "sse-channel": "^4.0.0",
     "terser": "^5.37.0",
     "typescript": "5.7.3",

package/src/data/live.ts

@@ -1,5 +1,5 @@
 import {catchError, concat, EMPTY, mergeMap, Observable, of} from 'rxjs'
-import {map} from 'rxjs/operators'
+import {finalize, map} from 'rxjs/operators'
 
 import {CorsOriginError} from '../http/errors'
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
@@ -11,6 +11,7 @@ import type {
   LiveEventWelcome,
   SyncTag,
 } from '../types'
+import {shareReplayLatest} from '../util/shareReplayLatest'
 import {_getDataUrl} from './dataMethods'
 import {connectEventSource} from './eventsource'
 import {eventSourcePolyfill} from './eventsourcePolyfill'
@@ -81,6 +82,13 @@ export class LiveClient {
       esOptions.withCredentials = true
     }
 
+    const key = `${url.href}::${JSON.stringify(esOptions)}`
+    const existing = eventsCache.get(key)
+
+    if (existing) {
+      return existing
+    }
+
     const initEventSource = () =>
       // use polyfill if there is no global EventSource or if we need to set headers
       (typeof EventSource === 'undefined' || esOptions.headers
@@ -118,7 +126,14 @@ export class LiveClient {
         throw new CorsOriginError({projectId: projectId!})
       }),
     )
-    return concat(checkCors, events)
+    const observable = concat(checkCors, events).pipe(
+      shareReplayLatest({
+        predicate: (event) => event.type === 'welcome',
+      }),
+      finalize(() => eventsCache.delete(key)),
+    )
+    eventsCache.set(key, observable)
+    return observable
   }
 }
 
@@ -140,3 +155,5 @@ function fetchObservable(url: URL, init: RequestInit) {
     return () => controller.abort()
   })
 }
+
+const eventsCache = new Map<string, Observable<LiveEvent>>()

package/src/types.ts

@@ -1291,7 +1291,6 @@ export interface LiveEventMessage {
 export interface LiveEventWelcome {
   type: 'welcome'
 }
-
 /** @public */
 export type LiveEvent = LiveEventRestart | LiveEventReconnect | LiveEventMessage | LiveEventWelcome
 

package/src/util/shareReplayLatest.ts

@@ -0,0 +1,71 @@
+import {
+  finalize,
+  merge,
+  type MonoTypeOperatorFunction,
+  Observable,
+  share,
+  type ShareConfig,
+  tap,
+} from 'rxjs'
+
+export type ShareReplayLatestConfig<T> = ShareConfig<T> & {predicate: (value: T) => boolean}
+
+/**
+ * A variant of share that takes a predicate function to determine which value to replay to new subscribers
+ * @param predicate - Predicate function to determine which value to replay
+ */
+export function shareReplayLatest<T>(predicate: (value: T) => boolean): MonoTypeOperatorFunction<T>
+
+/**
+ * A variant of share that takes a predicate function to determine which value to replay to new subscribers
+ * @param config - ShareConfig with additional predicate function
+ */
+export function shareReplayLatest<T>(
+  config: ShareReplayLatestConfig<T>,
+): MonoTypeOperatorFunction<T>
+
+/**
+ * A variant of share that takes a predicate function to determine which value to replay to new subscribers
+ * @param configOrPredicate - Predicate function to determine which value to replay
+ * @param config - Optional ShareConfig
+ */
+export function shareReplayLatest<T>(
+  configOrPredicate: ShareReplayLatestConfig<T> | ShareReplayLatestConfig<T>['predicate'],
+  config?: ShareConfig<T>,
+) {
+  return _shareReplayLatest(
+    typeof configOrPredicate === 'function'
+      ? {predicate: configOrPredicate, ...config}
+      : configOrPredicate,
+  )
+}
+function _shareReplayLatest<T>(config: ShareReplayLatestConfig<T>): MonoTypeOperatorFunction<T> {
+  return (source: Observable<T>) => {
+    let latest: T | undefined
+    let emitted = false
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {predicate, ...shareConfig} = config
+
+    const wrapped = source.pipe(
+      tap((value) => {
+        if (config.predicate(value)) {
+          emitted = true
+          latest = value
+        }
+      }),
+      finalize(() => {
+        emitted = false
+        latest = undefined
+      }),
+      share(shareConfig),
+    )
+    const emitLatest = new Observable<T>((subscriber) => {
+      if (emitted) {
+        subscriber.next(latest)
+      }
+      subscriber.complete()
+    })
+    return merge(wrapped, emitLatest)
+  }
+}

package/umd/sanityClient.js

@@ -1113,6 +1113,9 @@
   function popScheduler(args) {
       return isScheduler(last(args)) ? args.pop() : undefined;
   }
+  function popNumber(args, defaultValue) {
+      return typeof last(args) === 'number' ? args.pop() : defaultValue;
+  }
 
   var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
 
@@ -1619,6 +1622,7 @@
   }
 
   function mergeAll(concurrent) {
+      if (concurrent === undefined) { concurrent = Infinity; }
       return mergeMap(identity, concurrent);
   }
 
@@ -1659,6 +1663,24 @@
       });
   }
 
+  function merge() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+      }
+      var scheduler = popScheduler(args);
+      var concurrent = popNumber(args, Infinity);
+      var sources = args;
+      return !sources.length
+          ?
+              EMPTY
+          : sources.length === 1
+              ?
+                  innerFrom(sources[0])
+              :
+                  mergeAll(concurrent)(from(sources, scheduler));
+  }
+
   var isArray$1 = Array.isArray;
   function argsOrArgArray(args) {
       return args.length === 1 && isArray$1(args[0]) ? args[0] : args;
@@ -1716,6 +1738,17 @@
       return combineLatest.apply(undefined, __spreadArray([], __read(otherSources)));
   }
 
+  function finalize(callback) {
+      return operate(function (source, subscriber) {
+          try {
+              source.subscribe(subscriber);
+          }
+          finally {
+              subscriber.add(callback);
+          }
+      });
+  }
+
   function share(options) {
       if (options === undefined) { options = {}; }
       var _a = options.connector, connector = _a === undefined ? function () { return new Subject(); } : _a, _b = options.resetOnError, resetOnError = _b === undefined ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === undefined ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === undefined ? true : _d;
@@ -1810,6 +1843,42 @@
       });
   }
 
+  function tap(observerOrNext, error, complete) {
+      var tapObserver = isFunction(observerOrNext) || error || complete
+          ?
+              { next: observerOrNext, error: error, complete: complete }
+          : observerOrNext;
+      return tapObserver
+          ? operate(function (source, subscriber) {
+              var _a;
+              (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+              var isUnsub = true;
+              source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                  var _a;
+                  (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+                  subscriber.next(value);
+              }, function () {
+                  var _a;
+                  isUnsub = false;
+                  (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                  subscriber.complete();
+              }, function (err) {
+                  var _a;
+                  isUnsub = false;
+                  (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+                  subscriber.error(err);
+              }, function () {
+                  var _a, _b;
+                  if (isUnsub) {
+                      (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                  }
+                  (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+              }));
+          })
+          :
+              identity;
+  }
+
   var s = { 0: 8203, 1: 8204, 2: 8205, 3: 8290, 4: 8291, 5: 8288, 6: 65279, 7: 8289, 8: 119155, 9: 119156, a: 119157, b: 119158, c: 119159, d: 119160, e: 119161, f: 119162 }, c = { 0: 8203, 1: 8204, 2: 8205, 3: 65279 }, u = new Array(4).fill(String.fromCodePoint(c[0])).join("");
   function E(t) {
     let e = JSON.stringify(t);
@@ -2350,9 +2419,9 @@ ${selectionOpts}`);
     reset() {
       return this.operations = {}, this;
     }
-    _assign(op, props, merge = true) {
+    _assign(op, props, merge2 = true) {
       return validateObject(op, props), this.operations = Object.assign({}, this.operations, {
-        [op]: Object.assign({}, merge && this.operations[op] || {}, props)
+        [op]: Object.assign({}, merge2 && this.operations[op] || {}, props)
       }), this;
     }
     _set(op, props) {
@@ -2869,6 +2938,28 @@ ${selectionOpts}`);
       )
     );
   }
+  function shareReplayLatest(configOrPredicate, config) {
+    return _shareReplayLatest(
+      typeof configOrPredicate == "function" ? { predicate: configOrPredicate, ...config } : configOrPredicate
+    );
+  }
+  function _shareReplayLatest(config) {
+    return (source) => {
+      let latest, emitted = false;
+      const { predicate, ...shareConfig } = config, wrapped = source.pipe(
+        tap((value) => {
+          config.predicate(value) && (emitted = true, latest = value);
+        }),
+        finalize(() => {
+          emitted = false, latest = undefined;
+        }),
+        share(shareConfig)
+      ), emitLatest = new Observable((subscriber) => {
+        emitted && subscriber.next(latest), subscriber.complete();
+      });
+      return merge(wrapped, emitLatest);
+    };
+  }
   const requiredApiVersion = "2021-03-25";
   class LiveClient {
     #client;
@@ -2903,6 +2994,9 @@ ${selectionOpts}`);
       includeDrafts && token && (esOptions.headers = {
         Authorization: `Bearer ${token}`
       }), includeDrafts && withCredentials && (esOptions.withCredentials = true);
+      const key = `${url.href}::${JSON.stringify(esOptions)}`, existing = eventsCache.get(key);
+      if (existing)
+        return existing;
       const events = connectEventSource(() => (
         // use polyfill if there is no global EventSource or if we need to set headers
         (typeof EventSource > "u" || esOptions.headers ? eventSourcePolyfill : of(EventSource)).pipe(map((EventSource2) => new EventSource2(url.href, esOptions)))
@@ -2930,8 +3024,13 @@ ${selectionOpts}`);
         catchError(() => {
           throw new CorsOriginError({ projectId: projectId2 });
         })
+      ), observable2 = concat(checkCors, events).pipe(
+        shareReplayLatest({
+          predicate: (event) => event.type === "welcome"
+        }),
+        finalize(() => eventsCache.delete(key))
       );
-      return concat(checkCors, events);
+      return eventsCache.set(key, observable2), observable2;
     }
   }
   function fetchObservable(url, init) {
@@ -2947,6 +3046,7 @@ ${selectionOpts}`);
       ), () => controller.abort();
     });
   }
+  const eventsCache = /* @__PURE__ */ new Map();
   class ObservableDatasetsClient {
     #client;
     #httpRequest;