@legendapp/state 3.0.0-beta.45 → 3.0.0-beta.47

package/index.js

@@ -1229,6 +1229,16 @@ function observe(selectorOrRun, reactionOrOptions, options) {
   };
 }
 
+// src/toPrimitive.ts
+function toPrimitive(node, hint) {
+  const value = peek(node);
+  if (value === null || value === void 0 || isPrimitive(value)) {
+    return value;
+  }
+  const method = hint === "string" ? isFunction(value.toString) ? value.toString : value.valueOf : isFunction(value.valueOf) ? value.valueOf : value.toString;
+  return isFunction(method) ? method.call(value) : value;
+}
+
 // src/when.ts
 function _when(predicate, effect, checkReady) {
   if (isPromise(predicate)) {
@@ -1546,9 +1556,7 @@ var proxyHandler = {
   get(node, p, receiver) {
     var _a, _b, _c;
     if (p === symbolToPrimitive) {
-      throw new Error(
-        process.env.NODE_ENV === "development" ? "[legend-state] observable should not be used as a primitive. You may have forgotten to use .get() or .peek() to get the value of the observable." : "[legend-state] observable is not a primitive."
-      );
+      return (hint) => toPrimitive(node, hint);
     }
     if (p === symbolGetNode) {
       return node;
@@ -2432,6 +2440,12 @@ Object.defineProperty(ObservablePrimitiveClass.prototype, symbolGetNode, {
     return this._node;
   }
 });
+Object.defineProperty(ObservablePrimitiveClass.prototype, symbolToPrimitive, {
+  configurable: true,
+  value(hint) {
+    return toPrimitive(this._node, hint);
+  }
+});
 ObservablePrimitiveClass.prototype.toggle = function() {
   const value = this.peek();
   if (value === void 0 || value === null || isBoolean(value)) {

package/index.mjs

@@ -1227,6 +1227,16 @@ function observe(selectorOrRun, reactionOrOptions, options) {
   };
 }
 
+// src/toPrimitive.ts
+function toPrimitive(node, hint) {
+  const value = peek(node);
+  if (value === null || value === void 0 || isPrimitive(value)) {
+    return value;
+  }
+  const method = hint === "string" ? isFunction(value.toString) ? value.toString : value.valueOf : isFunction(value.valueOf) ? value.valueOf : value.toString;
+  return isFunction(method) ? method.call(value) : value;
+}
+
 // src/when.ts
 function _when(predicate, effect, checkReady) {
   if (isPromise(predicate)) {
@@ -1544,9 +1554,7 @@ var proxyHandler = {
   get(node, p, receiver) {
     var _a, _b, _c;
     if (p === symbolToPrimitive) {
-      throw new Error(
-        process.env.NODE_ENV === "development" ? "[legend-state] observable should not be used as a primitive. You may have forgotten to use .get() or .peek() to get the value of the observable." : "[legend-state] observable is not a primitive."
-      );
+      return (hint) => toPrimitive(node, hint);
     }
     if (p === symbolGetNode) {
       return node;
@@ -2430,6 +2438,12 @@ Object.defineProperty(ObservablePrimitiveClass.prototype, symbolGetNode, {
     return this._node;
   }
 });
+Object.defineProperty(ObservablePrimitiveClass.prototype, symbolToPrimitive, {
+  configurable: true,
+  value(hint) {
+    return toPrimitive(this._node, hint);
+  }
+});
 ObservablePrimitiveClass.prototype.toggle = function() {
   const value = this.peek();
   if (value === void 0 || value === null || isBoolean(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/state",
-  "version": "3.0.0-beta.45",
+  "version": "3.0.0-beta.47",
   "description": "legend-state",
   "sideEffects": false,
   "private": false,

package/sync-plugins/crud.js

@@ -48,35 +48,77 @@ function arrayToRecord(arr, keyField) {
   }
   return record;
 }
-function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, itemValueFull, actionFn, saveResult) {
-  if (action === "delete") {
-    if (queuedRetries.create.has(itemKey)) {
-      queuedRetries.create.delete(itemKey);
-    }
-    if (queuedRetries.update.has(itemKey)) {
-      queuedRetries.update.delete(itemKey);
-    }
-  } else {
-    if (queuedRetries.delete.has(itemKey)) {
-      queuedRetries.delete.delete(itemKey);
-    }
+function mergeQueuedRetryValue(currentValue, nextValue) {
+  if (currentValue && nextValue && typeof currentValue === "object" && typeof nextValue === "object") {
+    Object.assign(currentValue, nextValue);
+    return currentValue;
+  }
+  return nextValue;
+}
+function queueRetryValue(queuedRetries, itemKey, itemValue, itemValueFull) {
+  const queuedRetry = queuedRetries.get(itemKey);
+  if (queuedRetry) {
+    queuedRetry.value = mergeQueuedRetryValue(queuedRetry.value, itemValue);
+    queuedRetry.fullValue = mergeQueuedRetryValue(queuedRetry.fullValue, itemValueFull);
+    return queuedRetry;
   }
-  const queuedRetry = queuedRetries[action].get(itemKey);
+  const nextQueuedRetry = {
+    value: itemValue,
+    fullValue: itemValueFull
+  };
+  queuedRetries.set(itemKey, nextQueuedRetry);
+  return nextQueuedRetry;
+}
+function cancelQueuedRetry(queuedRetries, itemKey) {
+  const queuedRetry = queuedRetries.get(itemKey);
   if (queuedRetry) {
-    itemValue = Object.assign(queuedRetry, itemValue);
+    queuedRetry.cancelled = true;
+    queuedRetries.delete(itemKey);
+  }
+}
+function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, itemValueFull, actionFn, saveResult, options) {
+  if (action === "delete") {
+    cancelQueuedRetry(queuedRetries.create, itemKey);
+    cancelQueuedRetry(queuedRetries.update, itemKey);
+  } else {
+    cancelQueuedRetry(queuedRetries.delete, itemKey);
   }
-  queuedRetries[action].set(itemKey, itemValue);
-  const clonedValue = clone(itemValueFull);
+  const queuedRetry = queueRetryValue(queuedRetries[action], itemKey, itemValue, itemValueFull);
   const paramsWithChanges = { ...params, changes: [change] };
-  return runWithRetry(
-    paramsWithChanges,
-    retry,
-    "create_" + itemKey,
-    () => actionFn(itemValue, paramsWithChanges).then((result) => {
-      queuedRetries[action].delete(itemKey);
-      return saveResult(itemKey, clonedValue, result, true, change);
-    })
-  );
+  const runAttempt = () => {
+    var _a;
+    if (queuedRetry.cancelled) {
+      return Promise.resolve(void 0);
+    }
+    const refreshed = (_a = options == null ? void 0 : options.refreshValue) == null ? void 0 : _a.call(options);
+    const runWithRefreshedValue = (retryValue) => {
+      if (retryValue === false || queuedRetry.cancelled) {
+        queuedRetry.cancelled = true;
+        queuedRetries[action].delete(itemKey);
+        return Promise.resolve(void 0);
+      }
+      if (retryValue) {
+        queuedRetry.value = retryValue.value;
+        queuedRetry.fullValue = retryValue.fullValue;
+      }
+      const attemptValue = queuedRetry.value;
+      const attemptFullValue = clone(queuedRetry.fullValue);
+      return actionFn(attemptValue, paramsWithChanges).catch((error) => {
+        var _a2;
+        (_a2 = options == null ? void 0 : options.onAttemptFailure) == null ? void 0 : _a2.call(options);
+        throw error;
+      }).then(async (result) => {
+        queuedRetries[action].delete(itemKey);
+        if (queuedRetry.cancelled) {
+          return result;
+        }
+        await saveResult(itemKey, attemptFullValue, result, true, change);
+        return result;
+      });
+    };
+    return state.isPromise(refreshed) ? refreshed.then(runWithRefreshedValue) : runWithRefreshedValue(refreshed);
+  };
+  return runWithRetry(paramsWithChanges, retry, action + "_" + itemKey, runAttempt);
 }
 function syncedCrud(props) {
   const {
@@ -102,12 +144,53 @@ function syncedCrud(props) {
     ...rest
   } = props;
   const fieldId = fieldIdProp || "id";
-  const pendingCreates = /* @__PURE__ */ new Set();
+  const pendingCreates = /* @__PURE__ */ new Map();
   const queuedRetries = {
     create: /* @__PURE__ */ new Map(),
     update: /* @__PURE__ */ new Map(),
     delete: /* @__PURE__ */ new Map()
   };
+  const beginPendingCreate = (id, change) => {
+    const pendingCreate = pendingCreates.get(id) || { hasFailed: false };
+    pendingCreate.hasFailed = false;
+    pendingCreate.change || (pendingCreate.change = change);
+    pendingCreates.set(id, pendingCreate);
+    return pendingCreate;
+  };
+  const clearPendingCreate = (id) => {
+    if (!state.isNullOrUndefined(id)) {
+      pendingCreates.delete(id);
+      cancelQueuedRetry(queuedRetries.create, id);
+    }
+  };
+  const cancelFailedPendingCreate = (id) => {
+    var _a;
+    if (!state.isNullOrUndefined(id) && ((_a = pendingCreates.get(id)) == null ? void 0 : _a.hasFailed)) {
+      clearPendingCreate(id);
+      return true;
+    }
+    return false;
+  };
+  const clearPendingCreateForValue = (value) => {
+    if (value && typeof value === "object") {
+      clearPendingCreate(value[fieldId]);
+    }
+  };
+  const clearPendingCreatesForValues = (values) => {
+    if (values == null ? void 0 : values.length) {
+      for (let i = 0; i < values.length; i++) {
+        clearPendingCreateForValue(values[i]);
+      }
+    }
+  };
+  const markPendingCreateFailed = (itemKey) => {
+    const pendingCreate = pendingCreates.get(itemKey);
+    if (pendingCreate && !pendingCreate.hasFailed) {
+      pendingCreate.hasFailed = true;
+      cancelQueuedRetry(queuedRetries.update, itemKey);
+      cancelQueuedRetry(queuedRetries.delete, itemKey);
+    }
+  };
   let asType = props.as;
   if (!asType) {
     asType = getFn ? "value" : "object";
@@ -167,6 +250,7 @@ function syncedCrud(props) {
         };
         const processResults = (data) => {
           data || (data = []);
+          clearPendingCreatesForValues(data);
           if (fieldUpdatedAt) {
             const newLastSync = computeLastSync(data, fieldUpdatedAt, fieldCreatedAt);
             if (newLastSync && newLastSync !== lastSync) {
@@ -183,6 +267,7 @@ function syncedCrud(props) {
       } else if (getFn) {
         const dataPromise = getFn(getParams);
         const processData = (data) => {
+          clearPendingCreateForValue(data);
           let transformed = data;
           if (data) {
             const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
@@ -217,6 +302,28 @@ function syncedCrud(props) {
         !state.isNullOrUndefined(itemValue[fieldId]) ? { [fieldId]: itemValue[fieldId] } : {}
       ) : itemValue;
     };
+    const getCurrentValueAtKey = (itemKey) => {
+      const currentPeeked = state.getNodeValue(node);
+      if (asType === "value") {
+        return currentPeeked;
+      }
+      if (asType === "array") {
+        return state.isArray(currentPeeked) ? currentPeeked.find((value2) => (value2 == null ? void 0 : value2[fieldId]) === itemKey) : void 0;
+      }
+      if (asType === "Map") {
+        return currentPeeked == null ? void 0 : currentPeeked.get(itemKey);
+      }
+      return currentPeeked == null ? void 0 : currentPeeked[itemKey];
+    };
+    const isFailedCreateReadyToRetry = (itemKey) => {
+      const pendingCreate = pendingCreates.get(itemKey);
+      return !!(pendingCreate == null ? void 0 : pendingCreate.hasFailed) && !pendingCreate.promise;
+    };
+    const addCreate = (id, itemValue, change) => {
+      const pendingCreate = beginPendingCreate(id, change);
+      changesById.set(id, pendingCreate.change);
+      creates.set(id, itemValue);
+    };
     changes.forEach((change) => {
       var _a, _b;
       const { path, prevAtPath, valueAtPath, pathTypes } = change;
@@ -229,12 +336,14 @@ function syncedCrud(props) {
           const id = value[fieldId];
           if (!state.isNullOrUndefined(id)) {
             changesById.set(id, change);
-            if (pendingCreates.has(id)) {
+            if (isFailedCreateReadyToRetry(id)) {
+              isCreate = true;
+            } else if (pendingCreates.has(id)) {
               isCreate = false;
             }
             if (isCreate || retryAsCreate) {
               if (createFn) {
-                creates.set(id, value);
+                addCreate(id, value, change);
               } else {
                 console.warn("[legend-state] missing create function");
               }
@@ -259,8 +368,11 @@ function syncedCrud(props) {
             console.error("[legend-state]: added synced item without an id");
           }
         } else if (path.length === 0) {
-          deletes.add(prevAtPath);
-          changesById.set(prevAtPath[fieldId], change);
+          const id = prevAtPath == null ? void 0 : prevAtPath[fieldId];
+          if (!cancelFailedPendingCreate(id)) {
+            deletes.add(prevAtPath);
+            changesById.set(prevAtPath[fieldId], change);
+          }
         }
       } else {
         let itemsChanged = [];
@@ -283,7 +395,11 @@ function syncedCrud(props) {
           for (let i = 0; i < lengthPrev; i++) {
             const key = keysPrev[i];
             if (!keysSet.has(key)) {
-              deletes.add(prevAsObject[key]);
+              const prevValue = prevAsObject[key];
+              const id = prevValue == null ? void 0 : prevValue[fieldId];
+              if (!cancelFailedPendingCreate(id)) {
+                deletes.add(prevValue);
+              }
             }
           }
           for (let i = 0; i < length; i++) {
@@ -305,8 +421,11 @@ function syncedCrud(props) {
           const itemValue = asMap ? value.get(itemKey) : value[itemKey];
           if (!itemValue) {
             if (path.length === 1 && prevAtPath) {
-              deletes.add(prevAtPath);
-              changesById.set(prevAtPath[fieldId], change);
+              const id = prevAtPath[fieldId];
+              if (!cancelFailedPendingCreate(id)) {
+                deletes.add(prevAtPath);
+                changesById.set(id, change);
+              }
             }
           } else {
             if (generateId) {
@@ -322,27 +441,26 @@ function syncedCrud(props) {
           }
         }
         itemsChanged == null ? void 0 : itemsChanged.forEach(([item, prev, fullValue]) => {
-          const isCreate = !pendingCreates.has(item[fieldId]) && (fieldCreatedAt ? !item[fieldCreatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : fieldUpdatedAt ? !item[fieldUpdatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : state.isNullOrUndefined(prev));
+          const id = item[fieldId];
+          const isFailedCreateRetry = isFailedCreateReadyToRetry(id);
+          const isCreate = isFailedCreateRetry || !pendingCreates.has(id) && (fieldCreatedAt ? !item[fieldCreatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : fieldUpdatedAt ? !item[fieldUpdatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : state.isNullOrUndefined(prev));
           if (isCreate) {
-            if (!item[fieldId]) {
+            if (!id) {
               console.error("[legend-state]: added item without an id");
             }
             if (createFn) {
-              const id = item[fieldId];
-              changesById.set(id, change);
-              pendingCreates.add(id);
-              creates.set(id, item);
+              addCreate(id, isFailedCreateRetry ? fullValue : item, change);
             } else {
               console.warn("[legend-state] missing create function");
             }
           } else {
             if (updateFn) {
-              const id = item[fieldId];
-              changesById.set(id, change);
-              updates.set(id, updates.has(id) ? Object.assign(updates.get(id), item) : item);
+              const id2 = item[fieldId];
+              changesById.set(id2, change);
+              updates.set(id2, updates.has(id2) ? Object.assign(updates.get(id2), item) : item);
               updateFullValues.set(
-                id,
-                updateFullValues.has(id) ? Object.assign(updateFullValues.get(id), fullValue) : fullValue
+                id2,
+                updateFullValues.has(id2) ? Object.assign(updateFullValues.get(id2), fullValue) : fullValue
               );
             } else {
               console.warn("[legend-state] missing update function");
@@ -413,7 +531,28 @@ function syncedCrud(props) {
           await waitForSet(waitForSetParam, changes, itemValue, { type: "create" });
         }
         const createObj = await transformOut(itemValue, transform == null ? void 0 : transform.save);
-        return retrySet(
+        const pendingCreate = pendingCreates.get(itemKey) || { hasFailed: false };
+        pendingCreates.set(itemKey, pendingCreate);
+        const refreshCreateValue = async () => {
+          const currentPendingCreate = pendingCreates.get(itemKey);
+          if (!currentPendingCreate) {
+            return false;
+          }
+          if (!currentPendingCreate.hasFailed) {
+            return void 0;
+          }
+          const currentValue = getCurrentValueAtKey(itemKey);
+          if (state.isNullOrUndefined(currentValue)) {
+            clearPendingCreate(itemKey);
+            return false;
+          }
+          const nextCreateObj = await transformOut(
+            clone(currentValue),
+            transform == null ? void 0 : transform.save
+          );
+          return { value: nextCreateObj, fullValue: nextCreateObj };
+        };
+        const createPromise = retrySet(
           params,
           retry,
           "create",
@@ -423,13 +562,31 @@ function syncedCrud(props) {
           queuedRetries,
           createObj,
           createFn,
-          saveResult
-        ).then(() => {
-          pendingCreates.delete(itemKey);
+          saveResult,
+          {
+            onAttemptFailure: () => markPendingCreateFailed(itemKey),
+            refreshValue: refreshCreateValue
+          }
+        );
+        pendingCreate.promise = createPromise;
+        return createPromise.then((result) => {
+          if (pendingCreates.get(itemKey) === pendingCreate) {
+            pendingCreates.delete(itemKey);
+          }
+          return result;
+        }).catch((error) => {
+          if (pendingCreates.get(itemKey) === pendingCreate) {
+            pendingCreate.promise = void 0;
+          }
+          throw error;
         });
       }),
       // Handle updates
       ...Array.from(updates).map(async ([itemKey, itemValue]) => {
+        const pendingCreate = pendingCreates.get(itemKey);
+        if ((pendingCreate == null ? void 0 : pendingCreate.hasFailed) && pendingCreate.promise) {
+          await pendingCreate.promise;
+        }
         const fullValue = updateFullValues.get(itemKey);
         if (waitForSetParam) {
           await waitForSet(waitForSetParam, changes, fullValue, { type: "update" });
@@ -512,6 +669,7 @@ function syncedCrud(props) {
         paramsForUpdate.lastSync = newLastSync;
       }
       const rowsTransformed = (transform == null ? void 0 : transform.load) ? await transformRows(rows) : rows;
+      clearPendingCreatesForValues(rows);
       paramsForUpdate.value = resultsToOutType(rowsTransformed);
       params.update(paramsForUpdate);
     }

package/sync-plugins/crud.mjs

@@ -46,35 +46,77 @@ function arrayToRecord(arr, keyField) {
   }
   return record;
 }
-function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, itemValueFull, actionFn, saveResult) {
-  if (action === "delete") {
-    if (queuedRetries.create.has(itemKey)) {
-      queuedRetries.create.delete(itemKey);
-    }
-    if (queuedRetries.update.has(itemKey)) {
-      queuedRetries.update.delete(itemKey);
-    }
-  } else {
-    if (queuedRetries.delete.has(itemKey)) {
-      queuedRetries.delete.delete(itemKey);
-    }
+function mergeQueuedRetryValue(currentValue, nextValue) {
+  if (currentValue && nextValue && typeof currentValue === "object" && typeof nextValue === "object") {
+    Object.assign(currentValue, nextValue);
+    return currentValue;
+  }
+  return nextValue;
+}
+function queueRetryValue(queuedRetries, itemKey, itemValue, itemValueFull) {
+  const queuedRetry = queuedRetries.get(itemKey);
+  if (queuedRetry) {
+    queuedRetry.value = mergeQueuedRetryValue(queuedRetry.value, itemValue);
+    queuedRetry.fullValue = mergeQueuedRetryValue(queuedRetry.fullValue, itemValueFull);
+    return queuedRetry;
   }
-  const queuedRetry = queuedRetries[action].get(itemKey);
+  const nextQueuedRetry = {
+    value: itemValue,
+    fullValue: itemValueFull
+  };
+  queuedRetries.set(itemKey, nextQueuedRetry);
+  return nextQueuedRetry;
+}
+function cancelQueuedRetry(queuedRetries, itemKey) {
+  const queuedRetry = queuedRetries.get(itemKey);
   if (queuedRetry) {
-    itemValue = Object.assign(queuedRetry, itemValue);
+    queuedRetry.cancelled = true;
+    queuedRetries.delete(itemKey);
+  }
+}
+function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, itemValueFull, actionFn, saveResult, options) {
+  if (action === "delete") {
+    cancelQueuedRetry(queuedRetries.create, itemKey);
+    cancelQueuedRetry(queuedRetries.update, itemKey);
+  } else {
+    cancelQueuedRetry(queuedRetries.delete, itemKey);
   }
-  queuedRetries[action].set(itemKey, itemValue);
-  const clonedValue = clone(itemValueFull);
+  const queuedRetry = queueRetryValue(queuedRetries[action], itemKey, itemValue, itemValueFull);
   const paramsWithChanges = { ...params, changes: [change] };
-  return runWithRetry(
-    paramsWithChanges,
-    retry,
-    "create_" + itemKey,
-    () => actionFn(itemValue, paramsWithChanges).then((result) => {
-      queuedRetries[action].delete(itemKey);
-      return saveResult(itemKey, clonedValue, result, true, change);
-    })
-  );
+  const runAttempt = () => {
+    var _a;
+    if (queuedRetry.cancelled) {
+      return Promise.resolve(void 0);
+    }
+    const refreshed = (_a = options == null ? void 0 : options.refreshValue) == null ? void 0 : _a.call(options);
+    const runWithRefreshedValue = (retryValue) => {
+      if (retryValue === false || queuedRetry.cancelled) {
+        queuedRetry.cancelled = true;
+        queuedRetries[action].delete(itemKey);
+        return Promise.resolve(void 0);
+      }
+      if (retryValue) {
+        queuedRetry.value = retryValue.value;
+        queuedRetry.fullValue = retryValue.fullValue;
+      }
+      const attemptValue = queuedRetry.value;
+      const attemptFullValue = clone(queuedRetry.fullValue);
+      return actionFn(attemptValue, paramsWithChanges).catch((error) => {
+        var _a2;
+        (_a2 = options == null ? void 0 : options.onAttemptFailure) == null ? void 0 : _a2.call(options);
+        throw error;
+      }).then(async (result) => {
+        queuedRetries[action].delete(itemKey);
+        if (queuedRetry.cancelled) {
+          return result;
+        }
+        await saveResult(itemKey, attemptFullValue, result, true, change);
+        return result;
+      });
+    };
+    return isPromise(refreshed) ? refreshed.then(runWithRefreshedValue) : runWithRefreshedValue(refreshed);
+  };
+  return runWithRetry(paramsWithChanges, retry, action + "_" + itemKey, runAttempt);
 }
 function syncedCrud(props) {
   const {
@@ -100,12 +142,53 @@ function syncedCrud(props) {
     ...rest
   } = props;
   const fieldId = fieldIdProp || "id";
-  const pendingCreates = /* @__PURE__ */ new Set();
+  const pendingCreates = /* @__PURE__ */ new Map();
   const queuedRetries = {
     create: /* @__PURE__ */ new Map(),
     update: /* @__PURE__ */ new Map(),
     delete: /* @__PURE__ */ new Map()
   };
+  const beginPendingCreate = (id, change) => {
+    const pendingCreate = pendingCreates.get(id) || { hasFailed: false };
+    pendingCreate.hasFailed = false;
+    pendingCreate.change || (pendingCreate.change = change);
+    pendingCreates.set(id, pendingCreate);
+    return pendingCreate;
+  };
+  const clearPendingCreate = (id) => {
+    if (!isNullOrUndefined(id)) {
+      pendingCreates.delete(id);
+      cancelQueuedRetry(queuedRetries.create, id);
+    }
+  };
+  const cancelFailedPendingCreate = (id) => {
+    var _a;
+    if (!isNullOrUndefined(id) && ((_a = pendingCreates.get(id)) == null ? void 0 : _a.hasFailed)) {
+      clearPendingCreate(id);
+      return true;
+    }
+    return false;
+  };
+  const clearPendingCreateForValue = (value) => {
+    if (value && typeof value === "object") {
+      clearPendingCreate(value[fieldId]);
+    }
+  };
+  const clearPendingCreatesForValues = (values) => {
+    if (values == null ? void 0 : values.length) {
+      for (let i = 0; i < values.length; i++) {
+        clearPendingCreateForValue(values[i]);
+      }
+    }
+  };
+  const markPendingCreateFailed = (itemKey) => {
+    const pendingCreate = pendingCreates.get(itemKey);
+    if (pendingCreate && !pendingCreate.hasFailed) {
+      pendingCreate.hasFailed = true;
+      cancelQueuedRetry(queuedRetries.update, itemKey);
+      cancelQueuedRetry(queuedRetries.delete, itemKey);
+    }
+  };
   let asType = props.as;
   if (!asType) {
     asType = getFn ? "value" : "object";
@@ -165,6 +248,7 @@ function syncedCrud(props) {
         };
         const processResults = (data) => {
           data || (data = []);
+          clearPendingCreatesForValues(data);
           if (fieldUpdatedAt) {
             const newLastSync = computeLastSync(data, fieldUpdatedAt, fieldCreatedAt);
             if (newLastSync && newLastSync !== lastSync) {
@@ -181,6 +265,7 @@ function syncedCrud(props) {
       } else if (getFn) {
         const dataPromise = getFn(getParams);
         const processData = (data) => {
+          clearPendingCreateForValue(data);
           let transformed = data;
           if (data) {
             const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
@@ -215,6 +300,28 @@ function syncedCrud(props) {
         !isNullOrUndefined(itemValue[fieldId]) ? { [fieldId]: itemValue[fieldId] } : {}
       ) : itemValue;
     };
+    const getCurrentValueAtKey = (itemKey) => {
+      const currentPeeked = getNodeValue(node);
+      if (asType === "value") {
+        return currentPeeked;
+      }
+      if (asType === "array") {
+        return isArray(currentPeeked) ? currentPeeked.find((value2) => (value2 == null ? void 0 : value2[fieldId]) === itemKey) : void 0;
+      }
+      if (asType === "Map") {
+        return currentPeeked == null ? void 0 : currentPeeked.get(itemKey);
+      }
+      return currentPeeked == null ? void 0 : currentPeeked[itemKey];
+    };
+    const isFailedCreateReadyToRetry = (itemKey) => {
+      const pendingCreate = pendingCreates.get(itemKey);
+      return !!(pendingCreate == null ? void 0 : pendingCreate.hasFailed) && !pendingCreate.promise;
+    };
+    const addCreate = (id, itemValue, change) => {
+      const pendingCreate = beginPendingCreate(id, change);
+      changesById.set(id, pendingCreate.change);
+      creates.set(id, itemValue);
+    };
     changes.forEach((change) => {
       var _a, _b;
       const { path, prevAtPath, valueAtPath, pathTypes } = change;
@@ -227,12 +334,14 @@ function syncedCrud(props) {
           const id = value[fieldId];
           if (!isNullOrUndefined(id)) {
             changesById.set(id, change);
-            if (pendingCreates.has(id)) {
+            if (isFailedCreateReadyToRetry(id)) {
+              isCreate = true;
+            } else if (pendingCreates.has(id)) {
               isCreate = false;
             }
             if (isCreate || retryAsCreate) {
               if (createFn) {
-                creates.set(id, value);
+                addCreate(id, value, change);
               } else {
                 console.warn("[legend-state] missing create function");
               }
@@ -257,8 +366,11 @@ function syncedCrud(props) {
             console.error("[legend-state]: added synced item without an id");
           }
         } else if (path.length === 0) {
-          deletes.add(prevAtPath);
-          changesById.set(prevAtPath[fieldId], change);
+          const id = prevAtPath == null ? void 0 : prevAtPath[fieldId];
+          if (!cancelFailedPendingCreate(id)) {
+            deletes.add(prevAtPath);
+            changesById.set(prevAtPath[fieldId], change);
+          }
         }
       } else {
         let itemsChanged = [];
@@ -281,7 +393,11 @@ function syncedCrud(props) {
           for (let i = 0; i < lengthPrev; i++) {
             const key = keysPrev[i];
             if (!keysSet.has(key)) {
-              deletes.add(prevAsObject[key]);
+              const prevValue = prevAsObject[key];
+              const id = prevValue == null ? void 0 : prevValue[fieldId];
+              if (!cancelFailedPendingCreate(id)) {
+                deletes.add(prevValue);
+              }
             }
           }
           for (let i = 0; i < length; i++) {
@@ -303,8 +419,11 @@ function syncedCrud(props) {
           const itemValue = asMap ? value.get(itemKey) : value[itemKey];
           if (!itemValue) {
             if (path.length === 1 && prevAtPath) {
-              deletes.add(prevAtPath);
-              changesById.set(prevAtPath[fieldId], change);
+              const id = prevAtPath[fieldId];
+              if (!cancelFailedPendingCreate(id)) {
+                deletes.add(prevAtPath);
+                changesById.set(id, change);
+              }
             }
           } else {
             if (generateId) {
@@ -320,27 +439,26 @@ function syncedCrud(props) {
           }
         }
         itemsChanged == null ? void 0 : itemsChanged.forEach(([item, prev, fullValue]) => {
-          const isCreate = !pendingCreates.has(item[fieldId]) && (fieldCreatedAt ? !item[fieldCreatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : fieldUpdatedAt ? !item[fieldUpdatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : isNullOrUndefined(prev));
+          const id = item[fieldId];
+          const isFailedCreateRetry = isFailedCreateReadyToRetry(id);
+          const isCreate = isFailedCreateRetry || !pendingCreates.has(id) && (fieldCreatedAt ? !item[fieldCreatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : fieldUpdatedAt ? !item[fieldUpdatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : isNullOrUndefined(prev));
           if (isCreate) {
-            if (!item[fieldId]) {
+            if (!id) {
               console.error("[legend-state]: added item without an id");
             }
             if (createFn) {
-              const id = item[fieldId];
-              changesById.set(id, change);
-              pendingCreates.add(id);
-              creates.set(id, item);
+              addCreate(id, isFailedCreateRetry ? fullValue : item, change);
             } else {
               console.warn("[legend-state] missing create function");
             }
           } else {
             if (updateFn) {
-              const id = item[fieldId];
-              changesById.set(id, change);
-              updates.set(id, updates.has(id) ? Object.assign(updates.get(id), item) : item);
+              const id2 = item[fieldId];
+              changesById.set(id2, change);
+              updates.set(id2, updates.has(id2) ? Object.assign(updates.get(id2), item) : item);
               updateFullValues.set(
-                id,
-                updateFullValues.has(id) ? Object.assign(updateFullValues.get(id), fullValue) : fullValue
+                id2,
+                updateFullValues.has(id2) ? Object.assign(updateFullValues.get(id2), fullValue) : fullValue
               );
             } else {
               console.warn("[legend-state] missing update function");
@@ -411,7 +529,28 @@ function syncedCrud(props) {
           await waitForSet(waitForSetParam, changes, itemValue, { type: "create" });
         }
         const createObj = await transformOut(itemValue, transform == null ? void 0 : transform.save);
-        return retrySet(
+        const pendingCreate = pendingCreates.get(itemKey) || { hasFailed: false };
+        pendingCreates.set(itemKey, pendingCreate);
+        const refreshCreateValue = async () => {
+          const currentPendingCreate = pendingCreates.get(itemKey);
+          if (!currentPendingCreate) {
+            return false;
+          }
+          if (!currentPendingCreate.hasFailed) {
+            return void 0;
+          }
+          const currentValue = getCurrentValueAtKey(itemKey);
+          if (isNullOrUndefined(currentValue)) {
+            clearPendingCreate(itemKey);
+            return false;
+          }
+          const nextCreateObj = await transformOut(
+            clone(currentValue),
+            transform == null ? void 0 : transform.save
+          );
+          return { value: nextCreateObj, fullValue: nextCreateObj };
+        };
+        const createPromise = retrySet(
           params,
           retry,
           "create",
@@ -421,13 +560,31 @@ function syncedCrud(props) {
           queuedRetries,
           createObj,
           createFn,
-          saveResult
-        ).then(() => {
-          pendingCreates.delete(itemKey);
+          saveResult,
+          {
+            onAttemptFailure: () => markPendingCreateFailed(itemKey),
+            refreshValue: refreshCreateValue
+          }
+        );
+        pendingCreate.promise = createPromise;
+        return createPromise.then((result) => {
+          if (pendingCreates.get(itemKey) === pendingCreate) {
+            pendingCreates.delete(itemKey);
+          }
+          return result;
+        }).catch((error) => {
+          if (pendingCreates.get(itemKey) === pendingCreate) {
+            pendingCreate.promise = void 0;
+          }
+          throw error;
         });
       }),
       // Handle updates
       ...Array.from(updates).map(async ([itemKey, itemValue]) => {
+        const pendingCreate = pendingCreates.get(itemKey);
+        if ((pendingCreate == null ? void 0 : pendingCreate.hasFailed) && pendingCreate.promise) {
+          await pendingCreate.promise;
+        }
         const fullValue = updateFullValues.get(itemKey);
         if (waitForSetParam) {
           await waitForSet(waitForSetParam, changes, fullValue, { type: "update" });
@@ -510,6 +667,7 @@ function syncedCrud(props) {
         paramsForUpdate.lastSync = newLastSync;
       }
       const rowsTransformed = (transform == null ? void 0 : transform.load) ? await transformRows(rows) : rows;
+      clearPendingCreatesForValues(rows);
       paramsForUpdate.value = resultsToOutType(rowsTransformed);
       params.update(paramsForUpdate);
     }