jazz-tools 0.18.3 → 0.18.5

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   randomSessionProvider,
   subscribeToCoValue,
   zodReExport_exports
-} from "./chunk-IERUTUXB.js";
+} from "./chunk-3LE7N6TH.js";
 
 // src/tools/auth/clerk/index.ts
 import {

package/dist/react-core/index.js

@@ -314,7 +314,9 @@ var _CoMap = class _CoMap extends CoValueBase {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON(_key, processedValues) {
-    const result = {};
+    const result = {
+      $jazz: { id: this.$jazz.id }
+    };
     for (const key of this.$jazz.raw.keys()) {
       const tKey = key;
       const descriptor = this.$jazz.getDescriptor(tKey);
@@ -1643,6 +1645,7 @@ var _CoFeed = class _CoFeed extends CoValueBase {
     const itemDescriptor = this.$jazz.schema[ItemsSym];
     const mapper = itemDescriptor === "json" ? (v) => v : "encoded" in itemDescriptor ? itemDescriptor.encoded.encode : (v) => v && v.$jazz.id;
     return {
+      $jazz: { id: this.$jazz.id },
       ...Object.fromEntries(
         Object.entries(this).map(([account, entry]) => [
           account,
@@ -2091,6 +2094,7 @@ var FileStream = class extends CoValueBase {
    */
   toJSON() {
     return {
+      $jazz: { id: this.$jazz.id },
       ...this.getChunks()
     };
   }
@@ -2302,7 +2306,9 @@ var Account = class extends CoValueBase {
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON() {
-    return {};
+    return {
+      $jazz: { id: this.$jazz.id }
+    };
   }
   [inspect2]() {
     return this.toJSON();
@@ -3273,56 +3279,135 @@ function applyCoValueMigrations(instance) {
 
 // src/tools/subscribe/CoValueCoreSubscription.ts
 var CoValueCoreSubscription = class {
-  constructor(node, id, listener, skipRetry) {
-    this.node = node;
-    this.id = id;
-    this.listener = listener;
-    this.skipRetry = skipRetry;
+  constructor(localNode, id, listener, skipRetry, branch) {
     this._unsubscribe = () => {
     };
     this.unsubscribed = false;
-    const entry = this.node.getCoValue(this.id);
-    if (entry?.isAvailable()) {
-      this.subscribe(entry.getCurrentContent());
+    this.localNode = localNode;
+    this.listener = listener;
+    this.skipRetry = skipRetry;
+    this.branchName = branch?.name;
+    this.branchOwnerId = branch?.owner?.$jazz.raw.id;
+    this.source = localNode.getCoValue(id);
+    this.initializeSubscription();
+  }
+  /**
+   * Main entry point for subscription initialization.
+   * Determines the subscription strategy based on current availability and branch requirements.
+   */
+  initializeSubscription() {
+    const source = this.source;
+    if (source.isAvailable()) {
+      this.handleAvailableSource(source);
+      return;
+    }
+    if (this.branchName) {
+      this.handleBranchCheckout();
+      return;
+    }
+    this.loadCoValue();
+  }
+  /**
+   * Handles the case where the CoValue source is immediately available.
+   * Either subscribes directly or attempts to get the requested branch.
+   */
+  handleAvailableSource(source) {
+    if (!this.branchName) {
+      this.subscribe(source.getCurrentContent());
+      return;
+    }
+    const branch = source.getBranch(this.branchName, this.branchOwnerId);
+    if (branch.isAvailable()) {
+      this.subscribe(branch.getCurrentContent());
+      return;
     } else {
-      this.node.loadCoValueCore(this.id, void 0, skipRetry).then((value) => {
-        if (this.unsubscribed) return;
-        if (value.isAvailable()) {
-          this.subscribe(value.getCurrentContent());
-        } else {
-          this.subscribeToState();
-          this.listener("unavailable");
-        }
-      }).catch((error) => {
-        console.error("Unexpected error loading CoValue: ", error);
-        this.listener("unavailable");
-      });
+      this.handleBranchCheckout();
     }
   }
-  subscribeToState() {
-    const entry = this.node.getCoValue(this.id);
-    const handleStateChange = (core2, unsubFromStateChange2) => {
-      if (this.unsubscribed) {
-        unsubFromStateChange2();
-        return;
+  /**
+   * 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 !== "unavailable") {
+        this.subscribe(value);
+      } else {
+        this.handleUnavailableBranch();
       }
-      if (core2.isAvailable()) {
-        this.subscribe(core2.getCurrentContent());
-        unsubFromStateChange2();
+    }).catch((error) => {
+      console.error(error);
+      this.emit("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("unavailable");
+  }
+  /**
+   * Loads the CoValue core from the network/storage.
+   * This is the fallback strategy when immediate availability fails.
+   */
+  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();
+        this.emit("unavailable");
+      }
+    }).catch((error) => {
+      console.error(error);
+      this.emit("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.
+   */
+  subscribeToUnavailableSource() {
+    const source = this.source;
+    const handleStateChange = (_, unsubFromStateChange) => {
+      if (!source.isAvailable()) {
+        return;
       }
-    };
-    const unsubFromStateChange = entry.subscribe(handleStateChange);
-    this._unsubscribe = () => {
       unsubFromStateChange();
+      if (this.branchName) {
+        this.handleBranchCheckout();
+      } else {
+        this.subscribe(source.getCurrentContent());
+      }
     };
+    this._unsubscribe = source.subscribe(handleStateChange);
   }
+  /**
+   * Subscribes to a specific CoValue and notifies the listener.
+   * This is the final step where we actually start receiving updates.
+   */
   subscribe(value) {
     if (this.unsubscribed) return;
     this._unsubscribe = value.subscribe((value2) => {
-      this.listener(value2);
+      this.emit(value2);
     });
+  }
+  emit(value) {
+    if (this.unsubscribed) return;
     this.listener(value);
   }
+  /**
+   * Unsubscribes from all active subscriptions and marks the instance as unsubscribed.
+   * This prevents any further operations and ensures proper cleanup.
+   */
   unsubscribe() {
     if (this.unsubscribed) return;
     this.unsubscribed = true;