coaction 1.2.0 → 1.4.0

package/dist/index.mjs

@@ -53,18 +53,23 @@ var createAsyncClientStore = (createStore, asyncStoreClientOption) => {
   }
   asyncClientStore.transport = transport;
   let syncingPromise = null;
-  const fullSync = async () => {
+  let awaitingReconnectSync = false;
+  let reconnectSequenceBaseline = null;
+  const fullSync = async (allowLowerSequence = false) => {
     if (!syncingPromise) {
       syncingPromise = (async () => {
         const latest = await transport.emit("fullSync");
         if (typeof latest.sequence !== "number" || typeof latest.state !== "string") {
           throw new Error("Invalid fullSync payload");
         }
-        if (latest.sequence < internal.sequence) {
+        const canApplyLowerSequence = allowLowerSequence && awaitingReconnectSync && reconnectSequenceBaseline !== null && reconnectSequenceBaseline === internal.sequence;
+        if (latest.sequence < internal.sequence && !canApplyLowerSequence) {
           return;
         }
         asyncClientStore.apply(JSON.parse(latest.state));
         internal.sequence = latest.sequence;
+        awaitingReconnectSync = false;
+        reconnectSequenceBaseline = null;
       })().finally(() => {
         syncingPromise = null;
       });
@@ -75,28 +80,55 @@ var createAsyncClientStore = (createStore, asyncStoreClientOption) => {
     throw new Error("transport.onConnect is required");
   }
   transport.onConnect?.(() => {
-    void fullSync().catch((error) => {
+    awaitingReconnectSync = true;
+    reconnectSequenceBaseline = internal.sequence;
+    void fullSync(true).catch((error) => {
       if (process.env.NODE_ENV === "development") {
         console.error(error);
       }
     });
   });
   transport.listen("update", async (options) => {
+    let shouldFullSync = false;
+    let allowLowerSequence = false;
     try {
       if (typeof options.sequence !== "number") {
-        await fullSync();
-        return;
-      }
-      if (options.sequence <= internal.sequence) {
-        return;
-      }
-      if (options.sequence === internal.sequence + 1) {
-        internal.sequence = options.sequence;
+        shouldFullSync = true;
+      } else if (options.sequence <= internal.sequence) {
+        if (awaitingReconnectSync) {
+          shouldFullSync = true;
+          allowLowerSequence = true;
+        } else if (options.sequence === 0 && internal.sequence > 0) {
+          awaitingReconnectSync = true;
+          reconnectSequenceBaseline = internal.sequence;
+          shouldFullSync = true;
+          allowLowerSequence = true;
+        } else {
+          return;
+        }
+      } else if (options.sequence === internal.sequence + 1) {
         asyncClientStore.apply(void 0, options.patches);
+        internal.sequence = options.sequence;
+        awaitingReconnectSync = false;
+        reconnectSequenceBaseline = null;
+        return;
       } else {
-        await fullSync();
+        shouldFullSync = true;
+        allowLowerSequence = awaitingReconnectSync;
+      }
+      if (shouldFullSync) {
+        await fullSync(allowLowerSequence);
       }
     } catch (error) {
+      if (!shouldFullSync) {
+        try {
+          await fullSync(awaitingReconnectSync);
+        } catch (syncError) {
+          if (process.env.NODE_ENV === "development") {
+            console.error(syncError);
+          }
+        }
+      }
       if (process.env.NODE_ENV === "development") {
         console.error(error);
       }
@@ -187,12 +219,6 @@ var getInitialState = (store, createState, internal) => {
   ) : makeState(createState);
 };
 
-// src/getRawState.ts
-import {
-  create as createWithMutative,
-  isDraft
-} from "mutative";
-
 // src/utils.ts
 var isEqual = (x, y) => {
   if (x === y) {
@@ -200,6 +226,15 @@ var isEqual = (x, y) => {
   }
   return x !== x && y !== y;
 };
+var isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+var assignOwnEnumerable = (target, source) => {
+  for (const key of Object.keys(source)) {
+    if (isUnsafeKey(key)) {
+      continue;
+    }
+    target[key] = source[key];
+  }
+};
 var areShallowEqualWithArray = (prev, next) => {
   if (prev === null || next === null || prev.length !== next.length) {
     return false;
@@ -216,31 +251,253 @@ var mergeObject = (target, source, isSlice) => {
   if (isSlice) {
     if (typeof source === "object" && source !== null) {
       for (const key of Object.keys(source)) {
+        if (isUnsafeKey(key)) {
+          continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+          continue;
+        }
         const sourceValue = source[key];
         if (typeof sourceValue !== "object" || sourceValue === null) {
           continue;
         }
         const targetValue = target[key];
         if (typeof targetValue === "object" && targetValue !== null) {
-          Object.assign(targetValue, sourceValue);
+          assignOwnEnumerable(targetValue, sourceValue);
         }
       }
     }
   } else {
-    Object.assign(target, source);
+    if (typeof source === "object" && source !== null) {
+      assignOwnEnumerable(target, source);
+    }
   }
 };
 var uuid = () => {
   let timestamp = (/* @__PURE__ */ new Date()).getTime();
   const uuidTemplate = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
   const uuid2 = uuidTemplate.replace(/[xy]/g, (char) => {
-    let randomNum = (timestamp + Math.random() * 16) % 16 | 0;
+    const randomNum = (timestamp + Math.random() * 16) % 16 | 0;
     timestamp = Math.floor(timestamp / 16);
     return (char === "x" ? randomNum : randomNum & 3 | 8).toString(16);
   });
   return uuid2;
 };
 
+// src/getRawStateClientAction.ts
+var transportErrorMarker = "__coactionTransportError__";
+var isTransportErrorEnvelope = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[transportErrorMarker] === true && typeof value.message === "string";
+};
+var isLegacyTransportErrorEnvelope = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.$$Error === "string" && candidate.$$Error.length > 0 && Object.keys(candidate).length === 1;
+};
+var createClientAction = ({
+  clientExecuteSyncTimeoutMs,
+  internal,
+  key,
+  store,
+  sliceKey
+}) => {
+  return (...args) => {
+    let actionId;
+    let done;
+    if (store.trace) {
+      actionId = uuid();
+      store.trace({
+        method: key,
+        parameters: args,
+        id: actionId,
+        sliceKey
+      });
+      done = (result) => {
+        store.trace({
+          method: key,
+          id: actionId,
+          result,
+          sliceKey
+        });
+      };
+    }
+    const keys = sliceKey ? [sliceKey, key] : [key];
+    return store.transport.emit("execute", keys, args).then(async (response) => {
+      const result = Array.isArray(response) ? response[0] : response;
+      const sequence = Array.isArray(response) ? typeof response[1] === "number" ? response[1] : internal.sequence : internal.sequence;
+      if (internal.sequence < sequence) {
+        if (process.env.NODE_ENV === "development") {
+          console.warn(
+            `The sequence of the action is not consistent.`,
+            sequence,
+            internal.sequence
+          );
+        }
+        await new Promise((resolve, reject) => {
+          let settled = false;
+          let unsubscribe = () => {
+          };
+          const timeoutRef = {};
+          const cleanup = () => {
+            unsubscribe();
+            if (typeof timeoutRef.current !== "undefined") {
+              clearTimeout(timeoutRef.current);
+            }
+          };
+          const finishResolve = () => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            resolve();
+          };
+          const finishReject = (error) => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            reject(error);
+          };
+          unsubscribe = store.subscribe(() => {
+            if (internal.sequence >= sequence) {
+              finishResolve();
+            }
+          });
+          timeoutRef.current = setTimeout(() => {
+            void store.transport.emit("fullSync").then((latest) => {
+              const next = latest;
+              if (typeof next.state !== "string" || typeof next.sequence !== "number") {
+                throw new Error("Invalid fullSync payload");
+              }
+              store.apply(JSON.parse(next.state));
+              internal.sequence = next.sequence;
+              if (internal.sequence >= sequence) {
+                finishResolve();
+                return;
+              }
+              finishReject(
+                new Error(
+                  `Stale fullSync sequence: expected >= ${sequence}, got ${internal.sequence}`
+                )
+              );
+            }).catch((error) => {
+              finishReject(error);
+            });
+          }, clientExecuteSyncTimeoutMs);
+        });
+      }
+      if (isTransportErrorEnvelope(result)) {
+        done?.(result);
+        throw new Error(result.message);
+      }
+      if (isLegacyTransportErrorEnvelope(result)) {
+        done?.(result);
+        throw new Error(result.$$Error);
+      }
+      done?.(result);
+      return result;
+    });
+  };
+};
+
+// src/getRawStateLocalAction.ts
+import {
+  create as createWithMutative,
+  isDraft
+} from "mutative";
+var getActionTarget = (store, sliceKey) => {
+  return sliceKey ? store.getState()[sliceKey] : store.getState();
+};
+var createLocalAction = ({
+  fn,
+  internal,
+  key,
+  options,
+  store,
+  sliceKey
+}) => {
+  return (...args) => {
+    let actionId;
+    let done;
+    if (store.trace) {
+      actionId = uuid();
+      store.trace({
+        method: key,
+        parameters: args,
+        id: actionId,
+        sliceKey
+      });
+      done = (result2) => {
+        store.trace({
+          method: key,
+          id: actionId,
+          result: result2,
+          sliceKey
+        });
+      };
+    }
+    const enablePatches = store.transport ?? options.enablePatches;
+    if (internal.mutableInstance && !internal.isBatching && enablePatches) {
+      let result2;
+      const handleResult = (isDrafted2) => {
+        handleDraft(store, internal);
+        if (isDrafted2) {
+          internal.backupState = internal.rootState;
+          const [draft2, finalize2] = createWithMutative(internal.rootState, {
+            enablePatches: true
+          });
+          internal.finalizeDraft = finalize2;
+          internal.rootState = draft2;
+        }
+      };
+      const isDrafted = isDraft(internal.rootState);
+      if (isDrafted) {
+        handleResult();
+      }
+      internal.backupState = internal.rootState;
+      const [draft, finalize] = createWithMutative(internal.rootState, {
+        enablePatches: true
+      });
+      internal.finalizeDraft = finalize;
+      internal.rootState = draft;
+      let asyncResult;
+      try {
+        result2 = fn.apply(getActionTarget(store, sliceKey), args);
+        if (result2 instanceof Promise) {
+          asyncResult = result2;
+        }
+      } finally {
+        if (asyncResult) {
+        } else {
+          handleResult(isDrafted);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.finally(() => {
+          const result3 = handleResult(isDrafted);
+          done?.(result3);
+          return result3;
+        });
+      }
+      done?.(result2);
+      return result2;
+    }
+    if (internal.mutableInstance && internal.actMutable) {
+      const result2 = internal.actMutable(() => {
+        return fn.apply(getActionTarget(store, sliceKey), args);
+      });
+      done?.(result2);
+      return result2;
+    }
+    const result = fn.apply(getActionTarget(store, sliceKey), args);
+    done?.(result);
+    return result;
+  };
+};
+
 // src/computed.ts
 var Computed = class {
   constructor(deps, fn) {
@@ -274,23 +531,76 @@ var createSelectorCreatorWithArray = (memoize = defaultMemoize) => {
 };
 var createSelectorWithArray = createSelectorCreatorWithArray();
 
-// src/getRawState.ts
-var clientExecuteSyncTimeoutMs = 1500;
-var transportErrorMarker = "__coactionTransportError__";
-var isTransportErrorEnvelope = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
+// src/getRawStateStateProperty.ts
+var prepareStateDescriptor = ({
+  descriptor,
+  internal,
+  key,
+  rawState,
+  sliceKey
+}) => {
+  const isComputed = descriptor.value instanceof Computed;
+  if (internal.mutableInstance) {
+    Object.defineProperty(rawState, key, {
+      get: () => internal.mutableInstance[key],
+      set: (value) => {
+        internal.mutableInstance[key] = value;
+      },
+      enumerable: true
+    });
+  } else if (!isComputed) {
+    rawState[key] = descriptor.value;
   }
-  return value[transportErrorMarker] === true && typeof value.message === "string";
+  if (isComputed) {
+    if (internal.mutableInstance) {
+      throw new Error("Computed is not supported with mutable instance");
+    }
+    const { deps, fn } = descriptor.value;
+    const depsCallbackSelector = createSelectorWithArray(
+      // the root state should be updated, and the computed property will be updated.
+      () => [internal.rootState],
+      () => {
+        return deps(internal.module);
+      }
+    );
+    const selector = createSelectorWithArray(
+      (that) => depsCallbackSelector.call(that),
+      fn
+    );
+    descriptor.get = function() {
+      return selector.call(this);
+    };
+  } else if (sliceKey) {
+    descriptor.get = () => internal.rootState[sliceKey][key];
+    descriptor.set = (value) => {
+      internal.rootState[sliceKey][key] = value;
+    };
+  } else {
+    descriptor.get = () => internal.rootState[key];
+    descriptor.set = (value) => {
+      internal.rootState[key] = value;
+    };
+  }
+  delete descriptor.value;
+  delete descriptor.writable;
 };
-var isLegacyTransportErrorEnvelope = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
+
+// src/getRawState.ts
+var defaultClientExecuteSyncTimeoutMs = 1500;
+var getClientExecuteSyncTimeoutMs = (options) => {
+  const timeout = options.executeSyncTimeoutMs;
+  if (typeof timeout === "undefined") {
+    return defaultClientExecuteSyncTimeoutMs;
   }
-  const candidate = value;
-  return typeof candidate.$$Error === "string" && candidate.$$Error.length > 0 && Object.keys(candidate).length === 1;
+  if (!Number.isFinite(timeout) || timeout < 0) {
+    throw new Error(
+      "executeSyncTimeoutMs must be a finite number greater than or equal to 0"
+    );
+  }
+  return timeout;
 };
 var getRawState = (store, internal, initialState, options) => {
+  const clientExecuteSyncTimeoutMs = getClientExecuteSyncTimeoutMs(options);
   const rawState = {};
   const handle = (_rawState, _initialState, sliceKey) => {
     internal.mutableInstance = internal.toMutableRaw?.(_initialState);
@@ -298,234 +608,30 @@ var getRawState = (store, internal, initialState, options) => {
     Object.entries(descriptors).forEach(([key, descriptor]) => {
       if (Object.prototype.hasOwnProperty.call(descriptor, "value")) {
         if (typeof descriptor.value !== "function") {
-          const isComputed = descriptor.value instanceof Computed;
-          if (internal.mutableInstance) {
-            Object.defineProperty(_rawState, key, {
-              get: () => internal.mutableInstance[key],
-              set: (value) => {
-                internal.mutableInstance[key] = value;
-              },
-              enumerable: true
-            });
-          } else if (!isComputed) {
-            _rawState[key] = descriptor.value;
-          }
-          if (isComputed) {
-            if (internal.mutableInstance) {
-              throw new Error(
-                "Computed is not supported with mutable instance"
-              );
-            }
-            const { deps, fn } = descriptor.value;
-            const depsCallbackSelector = createSelectorWithArray(
-              // the root state should be updated, and the computed property will be updated.
-              () => [internal.rootState],
-              () => {
-                return deps(internal.module);
-              }
-            );
-            const selector = createSelectorWithArray(
-              (that) => depsCallbackSelector.call(that),
-              fn
-            );
-            descriptor.get = function() {
-              return selector.call(this);
-            };
-          } else {
-            if (sliceKey) {
-              descriptor.get = () => internal.rootState[sliceKey][key];
-              descriptor.set = (value) => {
-                internal.rootState[sliceKey][key] = value;
-              };
-            } else {
-              descriptor.get = () => internal.rootState[key];
-              descriptor.set = (value) => {
-                internal.rootState[key] = value;
-              };
-            }
-          }
-          delete descriptor.value;
-          delete descriptor.writable;
+          prepareStateDescriptor({
+            descriptor,
+            internal,
+            key,
+            rawState: _rawState,
+            sliceKey
+          });
         } else if (store.share === "client") {
-          descriptor.value = (...args) => {
-            let actionId;
-            let done;
-            if (store.trace) {
-              actionId = uuid();
-              store.trace({
-                method: key,
-                parameters: args,
-                id: actionId,
-                sliceKey
-              });
-              done = (result) => {
-                store.trace({
-                  method: key,
-                  id: actionId,
-                  result,
-                  sliceKey
-                });
-              };
-            }
-            const keys = sliceKey ? [sliceKey, key] : [key];
-            return store.transport.emit("execute", keys, args).then(async (response) => {
-              const result = Array.isArray(response) ? response[0] : response;
-              const sequence = Array.isArray(response) ? typeof response[1] === "number" ? response[1] : internal.sequence : internal.sequence;
-              if (internal.sequence < sequence) {
-                if (process.env.NODE_ENV === "development") {
-                  console.warn(
-                    `The sequence of the action is not consistent.`,
-                    sequence,
-                    internal.sequence
-                  );
-                }
-                await new Promise((resolve, reject) => {
-                  let settled = false;
-                  let unsubscribe = () => {
-                  };
-                  let timeoutId;
-                  const cleanup = () => {
-                    unsubscribe();
-                    if (typeof timeoutId !== "undefined") {
-                      clearTimeout(timeoutId);
-                    }
-                  };
-                  const finishResolve = () => {
-                    if (settled) return;
-                    settled = true;
-                    cleanup();
-                    resolve();
-                  };
-                  const finishReject = (error) => {
-                    if (settled) return;
-                    settled = true;
-                    cleanup();
-                    reject(error);
-                  };
-                  unsubscribe = store.subscribe(() => {
-                    if (internal.sequence >= sequence) {
-                      finishResolve();
-                    }
-                  });
-                  timeoutId = setTimeout(() => {
-                    void store.transport.emit("fullSync").then((latest) => {
-                      const next = latest;
-                      if (typeof next.state !== "string" || typeof next.sequence !== "number") {
-                        throw new Error("Invalid fullSync payload");
-                      }
-                      store.apply(JSON.parse(next.state));
-                      internal.sequence = next.sequence;
-                      if (internal.sequence >= sequence) {
-                        finishResolve();
-                        return;
-                      }
-                      finishReject(
-                        new Error(
-                          `Stale fullSync sequence: expected >= ${sequence}, got ${internal.sequence}`
-                        )
-                      );
-                    }).catch((error) => {
-                      finishReject(error);
-                    });
-                  }, clientExecuteSyncTimeoutMs);
-                });
-              }
-              if (isTransportErrorEnvelope(result)) {
-                done?.(result);
-                throw new Error(result.message);
-              }
-              if (isLegacyTransportErrorEnvelope(result)) {
-                done?.(result);
-                throw new Error(result.$$Error);
-              }
-              done?.(result);
-              return result;
-            });
-          };
+          descriptor.value = createClientAction({
+            clientExecuteSyncTimeoutMs,
+            internal,
+            key,
+            store,
+            sliceKey
+          });
         } else {
-          const fn = descriptor.value;
-          descriptor.value = (...args) => {
-            let actionId;
-            let done;
-            if (store.trace) {
-              actionId = uuid();
-              store.trace({
-                method: key,
-                parameters: args,
-                id: actionId,
-                sliceKey
-              });
-              done = (result2) => {
-                store.trace({
-                  method: key,
-                  id: actionId,
-                  result: result2,
-                  sliceKey
-                });
-              };
-            }
-            const enablePatches = store.transport ?? options.enablePatches;
-            if (internal.mutableInstance && !internal.isBatching && enablePatches) {
-              let result2;
-              const handleResult = (isDrafted2) => {
-                handleDraft(store, internal);
-                if (isDrafted2) {
-                  internal.backupState = internal.rootState;
-                  const [draft2, finalize2] = createWithMutative(
-                    internal.rootState,
-                    {
-                      enablePatches: true
-                    }
-                  );
-                  internal.finalizeDraft = finalize2;
-                  internal.rootState = draft2;
-                }
-              };
-              const isDrafted = isDraft(internal.rootState);
-              if (isDrafted) {
-                handleResult();
-              }
-              internal.backupState = internal.rootState;
-              const [draft, finalize] = createWithMutative(internal.rootState, {
-                enablePatches: true
-              });
-              internal.finalizeDraft = finalize;
-              internal.rootState = draft;
-              try {
-                result2 = fn.apply(
-                  sliceKey ? store.getState()[sliceKey] : store.getState(),
-                  args
-                );
-              } finally {
-                if (result2 instanceof Promise) {
-                  return result2.finally(() => {
-                    const result3 = handleResult(isDrafted);
-                    done?.(result3);
-                    return result3;
-                  });
-                }
-                handleResult(isDrafted);
-              }
-              done?.(result2);
-              return result2;
-            }
-            if (internal.mutableInstance && internal.actMutable) {
-              const result2 = internal.actMutable(() => {
-                return fn.apply(
-                  sliceKey ? store.getState()[sliceKey] : store.getState(),
-                  args
-                );
-              });
-              done?.(result2);
-              return result2;
-            }
-            const result = fn.apply(
-              sliceKey ? store.getState()[sliceKey] : store.getState(),
-              args
-            );
-            done?.(result);
-            return result;
-          };
+          descriptor.value = createLocalAction({
+            fn: descriptor.value,
+            internal,
+            key,
+            options,
+            store,
+            sliceKey
+          });
         }
       }
     });
@@ -771,6 +877,16 @@ var handleMainTransport = (store, internal, storeTransport, workerType, checkEna
 
 // src/create.ts
 var namespaceMap = /* @__PURE__ */ new Map();
+var hasWarnedAmbiguousFunctionMap = false;
+var warnAmbiguousFunctionMap = () => {
+  if (hasWarnedAmbiguousFunctionMap || process.env.NODE_ENV === "production" || process.env.NODE_ENV === "test") {
+    return;
+  }
+  hasWarnedAmbiguousFunctionMap = true;
+  console.warn(
+    `sliceMode: 'auto' inferred slices from an object of functions. This shape is ambiguous with a single store that only contains methods. Set sliceMode to 'slices' or 'single' explicitly.`
+  );
+};
 var create = (createState, options = {}) => {
   const checkEnablePatches = Object.hasOwnProperty.call(options, "enablePatches") && !options.enablePatches;
   const workerType = options.workerType ?? WorkerType;
@@ -826,34 +942,31 @@ var create = (createState, options = {}) => {
         }
       };
       const getPureState = () => internal2.rootState;
-      const inferSliceStore = () => {
+      const isFunctionMapObject = () => {
         if (typeof createState === "object" && createState !== null) {
           const values = Object.values(createState);
           return values.length > 0 && values.every((value) => typeof value === "function");
         }
         return false;
       };
-      const isValidSliceObject = () => {
-        if (typeof createState !== "object" || createState === null) {
-          return false;
-        }
-        const values = Object.values(createState);
-        return values.length > 0 && values.every((value) => typeof value === "function");
-      };
       const getIsSliceStore = () => {
         const sliceMode = options.sliceMode ?? "auto";
         if (sliceMode === "single") {
           return false;
         }
         if (sliceMode === "slices") {
-          if (!isValidSliceObject()) {
+          if (!isFunctionMapObject()) {
             throw new Error(
               `sliceMode: 'slices' requires createState to be an object of slice functions.`
             );
           }
           return true;
         }
-        return inferSliceStore();
+        if (isFunctionMapObject()) {
+          warnAmbiguousFunctionMap();
+          return true;
+        }
+        return false;
       };
       const isSliceStore = getIsSliceStore();
       Object.assign(store2, {