jazz-tools 0.19.2 → 0.19.4

package/dist/{chunk-NCNM6UDZ.js → chunk-PT7FCV26.js}

@@ -847,10 +847,13 @@ function getEditFromRaw(target, rawEdit, descriptor, key) {
       target
     ) : void 0,
     get by() {
-      return rawEdit.by && accessChildById(target, rawEdit.by, {
+      if (!rawEdit.by) return null;
+      const account = accessChildById(target, rawEdit.by, {
         ref: Account,
         optional: false
       });
+      if (!account.$isLoaded) return null;
+      return account;
     },
     madeAt: rawEdit.at,
     key
@@ -1792,10 +1795,13 @@ function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField)
       }
     },
     get by() {
-      return accountID && accessChildById(accessFrom, accountID, {
+      if (!accountID) return null;
+      const account = accessChildById(accessFrom, accountID, {
         ref: Account,
         optional: false
       });
+      if (!account.$isLoaded) return null;
+      return account;
     },
     madeAt: rawEntry.at,
     tx: rawEntry.tx
@@ -2602,7 +2608,11 @@ var _Group = class _Group extends CoValueBase {
           role,
           ref: ref2,
           get account() {
-            return accessChildById(group, accountID, refEncodedAccountSchema);
+            return accessChildById(
+              group,
+              accountID,
+              refEncodedAccountSchema
+            );
           }
         });
       }
@@ -2758,7 +2768,7 @@ function getCoValueOwner(coValue) {
     ref: RegisteredSchemas["Group"],
     optional: false
   });
-  if (!group) {
+  if (!group.$isLoaded) {
     throw new Error("CoValue has no owner");
   }
   return group;
@@ -3695,27 +3705,18 @@ var Ref = class {
       node = subscriptionScope.childNodes.get(this.id);
     }
     if (!node) {
-      return createUnloadedCoValue(this.id, CoValueLoadingState.LOADING);
+      return createUnloadedCoValue(this.id, CoValueLoadingState.UNAVAILABLE);
     }
-    const value = node.value;
-    if (value?.type === CoValueLoadingState.LOADED) {
-      return value.value;
+    const value = node.getCurrentValue();
+    if (value.$isLoaded) {
+      return value;
     } else {
       return new Promise((resolve) => {
         const unsubscribe = node.subscribe((value2) => {
-          if (value2?.type === CoValueLoadingState.LOADED) {
-            unsubscribe();
-            resolve(value2.value);
-          } else if (value2?.type === CoValueLoadingState.UNAVAILABLE) {
-            unsubscribe();
-            resolve(
-              createUnloadedCoValue(this.id, CoValueLoadingState.UNAVAILABLE)
-            );
-          } else if (value2?.type === CoValueLoadingState.UNAUTHORIZED) {
+          const currentValue = node.getCurrentValue();
+          if (currentValue.$jazz.loadingState !== CoValueLoadingState.LOADING) {
             unsubscribe();
-            resolve(
-              createUnloadedCoValue(this.id, CoValueLoadingState.UNAUTHORIZED)
-            );
+            resolve(currentValue);
           }
           if (subscriptionScope.closed) {
             node.destroy();
@@ -4334,7 +4335,30 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.value.type !== CoValueLoadingState.LOADED) return true;
     return this.pendingLoadedChildren.size === 0;
   }
+  getUnloadedValue(reason) {
+    if (this.unloadedValue?.$jazz.loadingState === reason) {
+      return this.unloadedValue;
+    }
+    const unloadedValue = {
+      $jazz: {
+        id: this.id,
+        loadingState: reason,
+        // @ts-expect-error - This is a private property
+        _subscriptionScope: this
+      },
+      $isLoaded: false
+    };
+    this.unloadedValue = unloadedValue;
+    return unloadedValue;
+  }
   getCurrentValue() {
+    const rawValue = this.getCurrentRawValue();
+    if (rawValue === CoValueLoadingState.UNAUTHORIZED || rawValue === CoValueLoadingState.UNAVAILABLE || rawValue === CoValueLoadingState.LOADING) {
+      return this.getUnloadedValue(rawValue);
+    }
+    return rawValue;
+  }
+  getCurrentRawValue() {
     if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
       console.error(this.value.toString());
       return this.value.type;
@@ -4414,7 +4438,7 @@ var SubscriptionScope = class _SubscriptionScope {
       return;
     }
     this.subscription.pullValue();
-    const value = this.getCurrentValue();
+    const value = this.getCurrentRawValue();
     if (typeof value !== "string") {
       listener({
         type: CoValueLoadingState.LOADED,
@@ -4542,6 +4566,10 @@ var SubscriptionScope = class _SubscriptionScope {
     if (key === "$onError") {
       return void 0;
     }
+    const skipInvalid = typeof depth === "object" && depth.$onError === "catch";
+    if (skipInvalid) {
+      this.skipInvalidKeys.add(key);
+    }
     const id = map.$jazz.raw.get(key);
     const descriptor = map.$jazz.getDescriptor(key);
     if (!descriptor) {
@@ -4677,12 +4705,12 @@ function accessChildByKey(parent, childId, key) {
   const value = subscriptionScope.childValues.get(childId);
   if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
-  } else {
-    return createUnloadedCoValue(
-      childId,
-      value?.type ?? CoValueLoadingState.LOADING
-    );
   }
+  const childNode = subscriptionScope.childNodes.get(childId);
+  if (!childNode) {
+    return createUnloadedCoValue(childId, CoValueLoadingState.UNAVAILABLE);
+  }
+  return childNode.getCurrentValue();
 }
 function accessChildById(parent, childId, schema) {
   const subscriptionScope = getSubscriptionScope(parent);
@@ -4690,12 +4718,12 @@ function accessChildById(parent, childId, schema) {
   const value = subscriptionScope.childValues.get(childId);
   if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
-  } else {
-    return createUnloadedCoValue(
-      childId,
-      value?.type ?? CoValueLoadingState.LOADING
-    );
   }
+  const childNode = subscriptionScope.childNodes.get(childId);
+  if (!childNode) {
+    return createUnloadedCoValue(childId, CoValueLoadingState.UNAVAILABLE);
+  }
+  return childNode.getCurrentValue();
 }
 
 // src/tools/implementation/createContext.ts
@@ -5783,7 +5811,9 @@ function schemaUnionDiscriminatorFor(schema) {
         if (match) {
           const coValueSchema = hydrateCoreCoValueSchema(option);
           const coValueClass = coValueSchema.getCoValueClass();
-          const dummyFieldNames = allNestedRefKeys.keys().filter((key) => !optionDef.shape[key]).toArray();
+          const dummyFieldNames = Array.from(allNestedRefKeys).filter(
+            (key) => !optionDef.shape[key]
+          );
           if (dummyFieldNames.length === 0) {
             return coValueClass;
           }
@@ -5846,16 +5876,28 @@ function makeCodecCoField(codec2) {
     }
   });
 }
+var schemaFieldCache = /* @__PURE__ */ new WeakMap();
+function cacheSchemaField(schema, value) {
+  schemaFieldCache.set(schema, value);
+  return value;
+}
 function schemaFieldToCoFieldDef(schema) {
+  const cachedCoFieldDef = schemaFieldCache.get(schema);
+  if (cachedCoFieldDef !== void 0) {
+    return cachedCoFieldDef;
+  }
   if (isCoValueClass(schema)) {
-    return coField.ref(schema);
+    return cacheSchemaField(schema, coField.ref(schema));
   } else if (isCoValueSchema(schema)) {
     if (schema.builtin === "CoOptional") {
-      return coField.ref(schema.getCoValueClass(), {
-        optional: true
-      });
+      return cacheSchemaField(
+        schema,
+        coField.ref(schema.getCoValueClass(), {
+          optional: true
+        })
+      );
     }
-    return coField.ref(schema.getCoValueClass());
+    return cacheSchemaField(schema, coField.ref(schema.getCoValueClass()));
   } else {
     if ("_zod" in schema) {
       const zodSchemaDef = schema._zod.def;
@@ -5865,35 +5907,44 @@ function schemaFieldToCoFieldDef(schema) {
         if (zodSchemaDef.type === "nullable" && coFieldDef === coField.optional.Date) {
           throw new Error("Nullable z.date() is not supported");
         }
-        return coFieldDef;
+        return cacheSchemaField(schema, coFieldDef);
       } else if (zodSchemaDef.type === "string") {
-        return coField.string;
+        return cacheSchemaField(schema, coField.string);
       } else if (zodSchemaDef.type === "number") {
-        return coField.number;
+        return cacheSchemaField(schema, coField.number);
       } else if (zodSchemaDef.type === "boolean") {
-        return coField.boolean;
+        return cacheSchemaField(schema, coField.boolean);
       } else if (zodSchemaDef.type === "null") {
-        return coField.null;
+        return cacheSchemaField(schema, coField.null);
       } else if (zodSchemaDef.type === "enum") {
-        return coField.string;
+        return cacheSchemaField(schema, coField.string);
       } else if (zodSchemaDef.type === "readonly") {
-        return schemaFieldToCoFieldDef(
-          schema.def.innerType
+        return cacheSchemaField(
+          schema,
+          schemaFieldToCoFieldDef(
+            schema.def.innerType
+          )
         );
       } else if (zodSchemaDef.type === "date") {
-        return coField.optional.Date;
+        return cacheSchemaField(schema, coField.optional.Date);
       } else if (zodSchemaDef.type === "template_literal") {
-        return coField.string;
+        return cacheSchemaField(schema, coField.string);
       } else if (zodSchemaDef.type === "lazy") {
-        return schemaFieldToCoFieldDef(
-          schema.unwrap()
+        return cacheSchemaField(
+          schema,
+          schemaFieldToCoFieldDef(
+            schema.unwrap()
+          )
         );
       } else if (zodSchemaDef.type === "default" || zodSchemaDef.type === "catch") {
         console.warn(
           "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored."
         );
-        return schemaFieldToCoFieldDef(
-          schema.def.innerType
+        return cacheSchemaField(
+          schema,
+          schemaFieldToCoFieldDef(
+            schema.def.innerType
+          )
         );
       } else if (zodSchemaDef.type === "literal") {
         if (zodSchemaDef.values.some((literal2) => typeof literal2 === "undefined")) {
@@ -5905,14 +5956,17 @@ function schemaFieldToCoFieldDef(schema) {
         if (zodSchemaDef.values.some((literal2) => typeof literal2 === "bigint")) {
           throw new Error("z.literal() with bigint is not supported");
         }
-        return coField.literal(
-          ...zodSchemaDef.values
+        return cacheSchemaField(
+          schema,
+          coField.literal(
+            ...zodSchemaDef.values
+          )
         );
       } else if (zodSchemaDef.type === "object" || zodSchemaDef.type === "record" || zodSchemaDef.type === "array" || zodSchemaDef.type === "tuple" || zodSchemaDef.type === "intersection") {
-        return coField.json();
+        return cacheSchemaField(schema, coField.json());
       } else if (zodSchemaDef.type === "union") {
         if (isUnionOfPrimitivesDeeply(schema)) {
-          return coField.json();
+          return cacheSchemaField(schema, coField.json());
         } else {
           throw new Error(
             "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead."
@@ -5933,8 +5987,11 @@ function schemaFieldToCoFieldDef(schema) {
           }
           throw error;
         }
-        return makeCodecCoField(
-          schema
+        return cacheSchemaField(
+          schema,
+          makeCodecCoField(
+            schema
+          )
         );
       } else {
         throw new Error(
@@ -6538,6 +6595,16 @@ globalThis.devtoolsFormatters = [
 function isCoValueClass(value) {
   return typeof value === "function" && value.fromRaw !== void 0;
 }
+var unloadedCoValueStates = /* @__PURE__ */ new Map();
+function getUnloadedCoValueWithoutId(loadingState) {
+  const value = unloadedCoValueStates.get(loadingState);
+  if (value) {
+    return value;
+  }
+  const newValue = createUnloadedCoValue("", loadingState);
+  unloadedCoValueStates.set(loadingState, newValue);
+  return newValue;
+}
 function createUnloadedCoValue(id, loadingState) {
   return {
     $jazz: { id, loadingState },
@@ -6561,12 +6628,8 @@ function loadCoValue(cls, id, options) {
         loadAs: options.loadAs,
         syncResolution: true,
         skipRetry: options.skipRetry,
-        onUnavailable: () => {
-          resolve(createUnloadedCoValue(id, CoValueLoadingState.UNAVAILABLE));
-        },
-        onUnauthorized: () => {
-          resolve(createUnloadedCoValue(id, CoValueLoadingState.UNAUTHORIZED));
-        },
+        onUnavailable: resolve,
+        onUnauthorized: resolve,
         unstable_branch: options.unstable_branch
       },
       (value, unsubscribe) => {
@@ -6643,29 +6706,35 @@ function subscribeToCoValue(cls, id, options, listener) {
     false,
     options.unstable_branch
   );
-  const handleUpdate = (value) => {
+  const handleUpdate = () => {
     if (unsubscribed) return;
-    if (value.type === CoValueLoadingState.UNAVAILABLE) {
-      options.onUnavailable?.();
-      if (!options.skipRetry) {
+    const value = rootNode.getCurrentValue();
+    if (value.$isLoaded) {
+      listener(value, unsubscribe);
+      return;
+    }
+    switch (value.$jazz.loadingState) {
+      case CoValueLoadingState.UNAVAILABLE:
+        options.onUnavailable?.(value);
+        if (!options.skipRetry) {
+          console.error(value.toString());
+        }
+        break;
+      case CoValueLoadingState.UNAUTHORIZED:
+        options.onUnauthorized?.(value);
         console.error(value.toString());
-      }
-    } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
-      options.onUnauthorized?.();
-      console.error(value.toString());
-    } else if (value.type === CoValueLoadingState.LOADED) {
-      listener(value.value, unsubscribe);
+        break;
     }
   };
   let shouldDefer = !options.syncResolution;
-  rootNode.setListener((value) => {
+  rootNode.setListener(() => {
     if (shouldDefer) {
       shouldDefer = false;
       Promise.resolve().then(() => {
-        handleUpdate(value);
+        handleUpdate();
       });
     } else {
-      handleUpdate(value);
+      handleUpdate();
     }
   });
   function unsubscribe() {
@@ -6823,7 +6892,7 @@ function loadContentPiecesFromSubscription(subscription, valuesExported, content
   }
   valuesExported.add(subscription.id);
   const currentValue = subscription.getCurrentValue();
-  if (typeof currentValue !== "string") {
+  if (currentValue.$isLoaded) {
     const core2 = currentValue.$jazz.raw.core;
     loadContentPiecesFromCoValue(core2, valuesExported, contentPieces);
   }
@@ -6901,6 +6970,7 @@ async function unstable_mergeBranchWithResolve(cls, id, options) {
 
 export {
   zodReExport_exports,
+  getUnloadedCoValueWithoutId,
   createUnloadedCoValue,
   loadCoValue,
   subscribeToCoValue,
@@ -6946,4 +7016,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-NCNM6UDZ.js.map
+//# sourceMappingURL=chunk-PT7FCV26.js.map