jazz-tools 0.19.8 → 0.19.10

package/dist/{chunk-2S3Z2CN6.js → chunk-FFEEPZEG.js}

@@ -3930,7 +3930,8 @@ function applyCoValueMigrations(instance) {
 
 // src/tools/subscribe/CoValueCoreSubscription.ts
 import {
-  cojsonInternals as cojsonInternals4
+  cojsonInternals as cojsonInternals4,
+  isRawCoID
 } from "cojson";
 
 // src/tools/subscribe/types.ts
@@ -3984,101 +3985,62 @@ var CoValueCoreSubscription = class {
    */
   initializeSubscription() {
     const source = this.source;
-    if (source.isAvailable()) {
-      this.handleAvailableSource();
+    if (!isRawCoID(source.id)) {
+      this.emit(CoValueLoadingState.UNAVAILABLE);
       return;
     }
     if (this.branchName) {
-      this.handleBranchCheckout();
+      this.handleBranching(this.branchName, this.branchOwnerId);
       return;
     }
-    this.loadCoValue();
+    this.subscribe(this.source);
   }
-  /**
-   * Handles the case where the CoValue source is immediately available.
-   * Either subscribes directly or attempts to get the requested branch.
-   */
-  handleAvailableSource() {
-    if (!this.branchName || !cojsonInternals4.canBeBranched(this.source)) {
-      this.subscribe(this.source.getCurrentContent());
+  handleBranching(branchName, branchOwnerId) {
+    const source = this.source;
+    if (!source.isAvailable()) {
+      this.waitForSourceToBecomeAvailable(branchName, branchOwnerId);
       return;
     }
-    const branch = this.source.getBranch(this.branchName, this.branchOwnerId);
-    if (branch.isAvailable()) {
-      this.subscribe(branch.getCurrentContent());
+    if (!cojsonInternals4.canBeBranched(source)) {
+      this.subscribe(source);
       return;
-    } else if (!this.source.hasBranch(this.branchName, this.branchOwnerId)) {
-      this.source.createBranch(this.branchName, this.branchOwnerId);
-      this.subscribe(branch.getCurrentContent());
-    } else {
-      this.handleBranchCheckout();
     }
-  }
-  /**
-   * Attempts to checkout a specific branch of the CoValue.
-   * This is called when the source isn't available but a branch is requested.
-   */
-  handleBranchCheckout() {
-    this.localNode.checkoutBranch(this.source.id, this.branchName, this.branchOwnerId).then((value) => {
-      if (this.unsubscribed) return;
-      if (value !== CoValueLoadingState.UNAVAILABLE) {
-        this.subscribe(value);
-      } else {
-        this.handleUnavailableBranch();
+    const branch = source.getBranch(branchName, branchOwnerId);
+    if (!branch.isAvailable() && !source.hasBranch(branchName, branchOwnerId)) {
+      try {
+        source.createBranch(branchName, branchOwnerId);
+      } catch (error) {
+        console.error("error creating branch", error);
+        this.emit(CoValueLoadingState.UNAVAILABLE);
+        return;
       }
-    }).catch((error) => {
-      console.error(error);
-      this.emit(CoValueLoadingState.UNAVAILABLE);
-    });
-  }
-  /**
-   * Handles the case where a branch checkout fails.
-   * Determines whether to retry or report unavailability.
-   */
-  handleUnavailableBranch() {
-    const source = this.source;
-    if (source.isAvailable()) {
-      throw new Error("Branch is unavailable");
     }
-    this.subscribeToUnavailableSource();
-    this.emit(CoValueLoadingState.UNAVAILABLE);
+    this.subscribe(branch);
   }
   /**
-   * Loads the CoValue core from the network/storage.
-   * This is the fallback strategy when immediate availability fails.
+   * Loads a CoValue core and emits an unavailable event if it is still unavailable after the retries.
    */
-  loadCoValue() {
-    this.localNode.loadCoValueCore(this.source.id, void 0, this.skipRetry).then((value) => {
-      if (this.unsubscribed) return;
-      if (value.isAvailable()) {
-        this.subscribe(value.getCurrentContent());
-      } else {
-        this.subscribeToUnavailableSource();
+  load(value) {
+    this.localNode.loadCoValueCore(value.id, void 0, this.skipRetry).then(() => {
+      if (!value.isAvailable()) {
         this.emit(CoValueLoadingState.UNAVAILABLE);
       }
-    }).catch((error) => {
-      console.error(error);
-      this.emit(CoValueLoadingState.UNAVAILABLE);
     });
   }
   /**
-   * Subscribes to state changes of an unavailable CoValue source.
-   * This allows the subscription to become active when the source becomes available after a first loading attempt.
+   * Waits for the source to become available and then tries to branch.
    */
-  subscribeToUnavailableSource() {
+  waitForSourceToBecomeAvailable(branchName, branchOwnerId) {
     const source = this.source;
     const handleStateChange = (_, unsubFromStateChange) => {
       if (!source.isAvailable()) {
         return;
       }
       unsubFromStateChange();
-      if (this.branchName) {
-        this.handleBranchCheckout();
-      } else {
-        this.subscribe(source.getCurrentContent());
-      }
+      this.handleBranching(branchName, branchOwnerId);
     };
     this._unsubscribe = source.subscribe(handleStateChange);
+    this.load(source);
   }
   /**
    * Subscribes to a specific CoValue and notifies the listener.
@@ -4087,16 +4049,30 @@ var CoValueCoreSubscription = class {
   subscribe(value) {
     if (this.unsubscribed) return;
     this._unsubscribe = value.subscribe((value2) => {
-      this.emit(value2);
+      if (value2.isAvailable()) {
+        this.emit(value2.getCurrentContent());
+      }
     });
+    if (!value.isAvailable()) {
+      this.load(value);
+    }
   }
   emit(value) {
     if (this.unsubscribed) return;
-    if (!isReadyForEmit(value)) {
+    if (!this.isReadyForEmit(value)) {
       return;
     }
     this.listener(value);
   }
+  isReadyForEmit(value) {
+    if (value === CoValueLoadingState.UNAVAILABLE) {
+      return true;
+    }
+    if (!isCompletelyDownloaded(value)) {
+      return false;
+    }
+    return true;
+  }
   /**
    * Unsubscribes from all active subscriptions and marks the instance as unsubscribed.
    * This prevents any further operations and ensures proper cleanup.
@@ -4107,10 +4083,7 @@ var CoValueCoreSubscription = class {
     this._unsubscribe();
   }
 };
-function isReadyForEmit(value) {
-  if (value === "unavailable") {
-    return true;
-  }
+function isCompletelyDownloaded(value) {
   return value.core.verified?.header.meta?.type === "binary" || value.core.isCompletelyDownloaded();
 }
 
@@ -4148,6 +4121,34 @@ var JazzError = class _JazzError {
   }
 };
 
+// src/tools/subscribe/errorReporting.ts
+var isDev = function() {
+  try {
+    return process.env.NODE_ENV === "development";
+  } catch {
+    return false;
+  }
+}();
+var customErrorReporter;
+var captureErrorCause = isDev;
+function enableCaptureErrorCause(capture) {
+  captureErrorCause = capture;
+}
+function setCustomErrorReporter(reporter) {
+  customErrorReporter = reporter;
+}
+function isCustomErrorReportingEnabled() {
+  return customErrorReporter !== void 0;
+}
+function captureStack() {
+  return captureErrorCause ? new Error() : void 0;
+}
+function captureError(error, props) {
+  if (customErrorReporter) {
+    customErrorReporter(error, props);
+  }
+}
+
 // src/tools/subscribe/utils.ts
 import { RawAccount as RawAccount4 } from "cojson";
 
@@ -4188,33 +4189,47 @@ function createCoValue(ref2, raw, subscriptionScope) {
     id: subscriptionScope.id
   };
 }
-
-// src/tools/subscribe/errorReporting.ts
-var isDev = function() {
-  try {
-    return process.env.NODE_ENV === "development";
-  } catch {
-    return false;
-  }
-}();
-var customErrorReporter;
-var captureErrorCause = isDev;
-function enableCaptureErrorCause(capture) {
-  captureErrorCause = capture;
-}
-function setCustomErrorReporter(reporter) {
-  customErrorReporter = reporter;
-}
-function isCustomErrorReportingEnabled() {
-  return customErrorReporter !== void 0;
+function resolvedPromise(value) {
+  const promise = Promise.resolve(value);
+  promise.status = "fulfilled";
+  promise.value = value;
+  return promise;
 }
-function captureStack() {
-  return captureErrorCause ? new Error() : void 0;
+function rejectedPromise(reason) {
+  const promise = Promise.reject(reason);
+  promise.status = "rejected";
+  promise.reason = reason;
+  return promise;
 }
-function captureError(error, props) {
-  if (customErrorReporter) {
-    customErrorReporter(error, props);
+function isEqualRefsToResolve(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b;
+  }
+  if (typeof a === "boolean" || typeof b === "boolean") {
+    return false;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
   }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!(key in b)) {
+      return false;
+    }
+    const valueA = a[key];
+    const valueB = b[key];
+    if (!isEqualRefsToResolve(valueA, valueB)) {
+      return false;
+    }
+  }
+  return true;
 }
 
 // src/tools/subscribe/SubscriptionScope.ts
@@ -4273,6 +4288,7 @@ var SubscriptionScope = class _SubscriptionScope {
       this.triggerUpdate();
     };
     this.subscribers = /* @__PURE__ */ new Set();
+    this.subscriberChangeCallbacks = /* @__PURE__ */ new Set();
     this.callerStack = callerStack;
     this.resolve = resolve;
     this.value = { type: CoValueLoadingState.LOADING, id };
@@ -4401,6 +4417,48 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.value.type !== CoValueLoadingState.LOADED) return true;
     return this.pendingLoadedChildren.size === 0;
   }
+  cachePromise(value, callback) {
+    if (this.lastPromise?.value === value) {
+      return this.lastPromise.promise;
+    }
+    const promise = callback();
+    this.lastPromise = { value, promise };
+    return promise;
+  }
+  getPromise() {
+    const currentValue = this.getCurrentValue();
+    if (currentValue.$isLoaded) {
+      return resolvedPromise(currentValue);
+    }
+    if (currentValue.$jazz.loadingState !== CoValueLoadingState.LOADING) {
+      const error = this.getError();
+      return rejectedPromise(
+        new Error(error?.toString() ?? "Unknown error", {
+          cause: this.callerStack
+        })
+      );
+    }
+    return this.cachePromise(currentValue, () => {
+      return new Promise((resolve, reject) => {
+        const unsubscribe = this.subscribe(() => {
+          const currentValue2 = this.getCurrentValue();
+          if (currentValue2.$jazz.loadingState === CoValueLoadingState.LOADING) {
+            return;
+          }
+          if (currentValue2.$isLoaded) {
+            resolve(currentValue2);
+          } else {
+            reject(
+              new Error(this.getError()?.toString() ?? "Unknown error", {
+                cause: this.callerStack
+              })
+            );
+          }
+          unsubscribe();
+        });
+      });
+    });
+  }
   getUnloadedValue(reason) {
     if (this.unloadedValue?.$jazz.loadingState === reason) {
       return this.unloadedValue;
@@ -4451,14 +4509,16 @@ var SubscriptionScope = class _SubscriptionScope {
     }
     return result;
   }
-  logError() {
-    let error;
+  getError() {
     if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
-      error = this.value;
+      return this.value;
     }
     if (this.errorFromChildren) {
-      error = this.errorFromChildren;
+      return this.errorFromChildren;
     }
+  }
+  logError() {
+    const error = this.getError();
     if (!error || this.lastErrorLogged === error) {
       return;
     }
@@ -4489,14 +4549,37 @@ var SubscriptionScope = class _SubscriptionScope {
     }
     this.dirty = false;
   }
+  /**
+   * Subscribe to subscriber count changes
+   * Callback receives the total number of subscribers
+   * Returns an unsubscribe function
+   */
+  onSubscriberChange(callback) {
+    this.subscriberChangeCallbacks.add(callback);
+    return () => {
+      this.subscriberChangeCallbacks.delete(callback);
+    };
+  }
+  notifySubscriberChange() {
+    const count = this.subscribers.size;
+    this.subscriberChangeCallbacks.forEach((callback) => {
+      callback(count);
+    });
+  }
   subscribe(listener) {
     this.subscribers.add(listener);
+    this.notifySubscriberChange();
     return () => {
       this.subscribers.delete(listener);
+      this.notifySubscriberChange();
     };
   }
   setListener(listener) {
+    const hadListener = this.subscribers.has(listener);
     this.subscribers.add(listener);
+    if (!hadListener) {
+      this.notifySubscriberChange();
+    }
     this.triggerUpdate();
   }
   subscribeToKey(key) {
@@ -4765,7 +4848,12 @@ var SubscriptionScope = class _SubscriptionScope {
   destroy() {
     this.closed = true;
     this.subscription.unsubscribe();
+    const hadSubscribers = this.subscribers.size > 0;
     this.subscribers.clear();
+    if (hadSubscribers) {
+      this.notifySubscriberChange();
+    }
+    this.subscriberChangeCallbacks.clear();
     this.childNodes.forEach((child) => child.destroy());
   }
 };
@@ -6381,6 +6469,177 @@ var InMemoryKVStore = class {
   }
 };
 
+// src/tools/subscribe/SubscriptionCache.ts
+var SubscriptionCache = class {
+  constructor(cleanupTimeout = 5e3) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupTimeout = cleanupTimeout;
+  }
+  /**
+   * Get the inner set for a given id (read-only access)
+   */
+  getIdSet(id) {
+    return this.cache.get(id);
+  }
+  /**
+   * Get the inner set for a given id, creating it if it doesn't exist
+   */
+  getIdSetOrCreate(id) {
+    let idSet = this.cache.get(id);
+    if (!idSet) {
+      idSet = /* @__PURE__ */ new Set();
+      this.cache.set(id, idSet);
+    }
+    return idSet;
+  }
+  /**
+   * Check if an entry matches the provided parameters
+   */
+  matchesEntry(entry, schema, resolve, branch) {
+    if (entry.schema !== schema) {
+      return false;
+    }
+    if (!isEqualRefsToResolve(entry.resolve, resolve)) {
+      return false;
+    }
+    const branchName = branch?.name;
+    if (entry.branch?.name !== branchName) {
+      return false;
+    }
+    const branchOwnerId = branch?.owner?.$jazz.id;
+    if (entry.branch?.owner?.$jazz.id !== branchOwnerId) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Find a matching cache entry by comparing against entry properties
+   * Uses id-based nesting to quickly filter candidates
+   */
+  findMatchingEntry(schema, id, resolve, branch) {
+    const idSet = this.getIdSet(id);
+    if (!idSet) {
+      return void 0;
+    }
+    for (const entry of idSet) {
+      if (this.matchesEntry(entry, schema, resolve, branch)) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Handle subscriber count changes from SubscriptionScope
+   */
+  handleSubscriberChange(entry, count) {
+    entry.subscriberCount = count;
+    if (count === 0) {
+      this.scheduleCleanup(entry);
+    } else {
+      this.cancelCleanup(entry);
+    }
+  }
+  /**
+   * Schedule cleanup timeout for an entry
+   */
+  scheduleCleanup(entry) {
+    this.cancelCleanup(entry);
+    entry.cleanupTimeoutId = setTimeout(() => {
+      this.destroyEntry(entry);
+    }, this.cleanupTimeout);
+  }
+  /**
+   * Cancel pending cleanup timeout for an entry
+   */
+  cancelCleanup(entry) {
+    if (entry.cleanupTimeoutId !== void 0) {
+      clearTimeout(entry.cleanupTimeoutId);
+      entry.cleanupTimeoutId = void 0;
+    }
+  }
+  /**
+   * Destroy a cache entry and its SubscriptionScope
+   */
+  destroyEntry(entry) {
+    this.cancelCleanup(entry);
+    entry.unsubscribeFromScope();
+    try {
+      entry.subscriptionScope.destroy();
+    } catch (error) {
+      console.error("Error destroying SubscriptionScope:", error);
+    }
+    const id = entry.subscriptionScope.id;
+    const idSet = this.getIdSet(id);
+    if (idSet) {
+      idSet.delete(entry);
+      if (idSet.size === 0) {
+        this.cache.delete(id);
+      }
+    }
+  }
+  /**
+   * Get or create a SubscriptionScope from the cache
+   */
+  getOrCreate(node, schema, id, resolve, skipRetry, bestEffortResolution, branch) {
+    if (!id) {
+      throw new Error("Cannot create subscription with undefined or null id");
+    }
+    const matchingEntry = this.findMatchingEntry(schema, id, resolve, branch);
+    if (matchingEntry) {
+      this.cancelCleanup(matchingEntry);
+      return matchingEntry.subscriptionScope;
+    }
+    const refEncoded = {
+      ref: coValueClassFromCoValueClassOrSchema(schema),
+      optional: true
+    };
+    const subscriptionScope = new SubscriptionScope(
+      node,
+      // @ts-expect-error the SubscriptionScope is too generic for TS to infer its instances are CoValues
+      resolve,
+      id,
+      refEncoded,
+      skipRetry ?? false,
+      bestEffortResolution ?? false,
+      branch
+    );
+    const handleSubscriberChange = (count) => {
+      const idSet2 = this.getIdSet(id);
+      if (idSet2 && idSet2.has(entry)) {
+        this.handleSubscriberChange(entry, count);
+      }
+    };
+    const entry = {
+      subscriptionScope,
+      schema,
+      resolve,
+      branch,
+      subscriberCount: subscriptionScope.subscribers.size,
+      unsubscribeFromScope: subscriptionScope.onSubscriberChange(
+        handleSubscriberChange
+      )
+    };
+    const idSet = this.getIdSetOrCreate(id);
+    idSet.add(entry);
+    return subscriptionScope;
+  }
+  /**
+   * Clear all cache entries and destroy all SubscriptionScope instances
+   */
+  clear() {
+    const entriesToDestroy = [];
+    for (const idSet of this.cache.values()) {
+      for (const entry of idSet) {
+        entriesToDestroy.push(entry);
+      }
+    }
+    for (const entry of entriesToDestroy) {
+      this.destroyEntry(entry);
+    }
+    this.cache.clear();
+  }
+};
+
 // src/tools/implementation/ContextManager.ts
 function getAnonymousFallback() {
   const context = createAnonymousJazzContext({
@@ -6414,6 +6673,7 @@ var JazzContextManager = class {
         return;
       }
       this.authenticatingAccountID = null;
+      this.subscriptionCache.clear();
       await this.props.onLogOut?.();
       if (this.props.logOutReplacement) {
         await this.props.logOutReplacement();
@@ -6511,6 +6771,7 @@ var JazzContextManager = class {
     };
     KvStoreContext.getInstance().initialize(this.getKvStore());
     this.authSecretStorage = new AuthSecretStorage(opts?.authSecretStorageKey);
+    this.subscriptionCache = new SubscriptionCache();
     if (opts?.useAnonymousFallback) {
       this.value = getAnonymousFallback();
     }
@@ -6539,6 +6800,7 @@ var JazzContextManager = class {
     throw new Error("Not implemented");
   }
   async updateContext(props, context, authProps) {
+    this.subscriptionCache.clear();
     if (!this.keepContextOpen) {
       this.context?.done();
     }
@@ -6576,6 +6838,9 @@ var JazzContextManager = class {
   getAuthenticatingAccountID() {
     return this.authenticatingAccountID;
   }
+  getSubscriptionScopeCache() {
+    return this.subscriptionCache;
+  }
   async handleAnonymousAccountMigration(prevContext) {
     if (!this.props) {
       throw new Error("Props required");
@@ -7129,4 +7394,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-2S3Z2CN6.js.map
+//# sourceMappingURL=chunk-FFEEPZEG.js.map