coaction 1.1.0 → 1.3.0

package/dist/index.js

@@ -80,23 +80,86 @@ var createAsyncClientStore = (createStore, asyncStoreClientOption) => {
     throw new Error("transport is required");
   }
   asyncClientStore.transport = transport;
-  const fullSync = async () => {
-    const latest = await transport.emit("fullSync");
-    asyncClientStore.apply(JSON.parse(latest.state));
-    internal.sequence = latest.sequence;
+  let syncingPromise = null;
+  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");
+        }
+        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;
+      });
+    }
+    return syncingPromise;
   };
   if (typeof transport.onConnect !== "function") {
     throw new Error("transport.onConnect is required");
   }
-  transport.onConnect?.(async () => {
-    await fullSync();
+  transport.onConnect?.(() => {
+    awaitingReconnectSync = true;
+    reconnectSequenceBaseline = internal.sequence;
+    void fullSync(true).catch((error) => {
+      if (process.env.NODE_ENV === "development") {
+        console.error(error);
+      }
+    });
   });
   transport.listen("update", async (options) => {
-    if (typeof options.sequence === "number" && options.sequence === internal.sequence + 1) {
-      internal.sequence = options.sequence;
-      asyncClientStore.apply(void 0, options.patches);
-    } else {
-      await fullSync();
+    let shouldFullSync = false;
+    let allowLowerSequence = false;
+    try {
+      if (typeof options.sequence !== "number") {
+        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 {
+        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);
+      }
     }
   });
   return wrapStore(asyncClientStore, () => asyncClientStore.getState());
@@ -131,6 +194,7 @@ var isObject = (value) => typeof value === "object" && value !== null;
 var isStateFactory = (value) => typeof value === "function";
 var hasGetState = (value) => (typeof value === "object" || typeof value === "function") && value !== null && typeof value.getState === "function";
 var hasBindState = (value) => isObject(value) && !!value[bindSymbol];
+var formatInvalidStateMessage = (type, stateOrFn, key) => `Invalid state ${type} encountered in makeState: ${key ? `for key ${key}, ` : ""}${typeof stateOrFn}`;
 var getInitialState = (store, createState, internal) => {
   const makeState = (stateOrFn, key) => {
     let state;
@@ -140,9 +204,7 @@ var getInitialState = (store, createState, internal) => {
       state = stateOrFn;
     } else {
       if (process.env.NODE_ENV !== "production") {
-        throw new Error(
-          `Invalid state value encountered in makeState: ${key ? `for key ${key}, ` : ""}${typeof stateOrFn}`
-        );
+        throw new Error(formatInvalidStateMessage("value", stateOrFn, key));
       }
       return {};
     }
@@ -169,6 +231,12 @@ var getInitialState = (store, createState, internal) => {
       delete state[bindSymbol];
       return rawState;
     }
+    if (!isObject(state)) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(formatInvalidStateMessage("result", state, key));
+      }
+      return {};
+    }
     return state;
   };
   return store.isSliceStore ? Object.entries(createState).reduce(
@@ -189,6 +257,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;
@@ -204,14 +281,27 @@ var areShallowEqualWithArray = (prev, next) => {
 var mergeObject = (target, source, isSlice) => {
   if (isSlice) {
     if (typeof source === "object" && source !== null) {
-      for (const key in source) {
-        if (typeof source[key] === "object" && source[key] !== null) {
-          Object.assign(target[key], source[key]);
+      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) {
+          assignOwnEnumerable(targetValue, sourceValue);
         }
       }
     }
   } else {
-    Object.assign(target, source);
+    if (typeof source === "object" && source !== null) {
+      assignOwnEnumerable(target, source);
+    }
   }
 };
 var uuid = () => {
@@ -260,6 +350,20 @@ var createSelectorWithArray = createSelectorCreatorWithArray();
 
 // src/getRawState.ts
 var clientExecuteSyncTimeoutMs = 1500;
+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 getRawState = (store, internal, initialState, options) => {
   const rawState = {};
   const handle = (_rawState, _initialState, sliceKey) => {
@@ -338,7 +442,9 @@ var getRawState = (store, internal, initialState, options) => {
               };
             }
             const keys = sliceKey ? [sliceKey, key] : [key];
-            return store.transport.emit("execute", keys, args).then(async ([result, sequence]) => {
+            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(
@@ -378,16 +484,31 @@ var getRawState = (store, internal, initialState, options) => {
                   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;
-                      finishResolve();
+                      if (internal.sequence >= sequence) {
+                        finishResolve();
+                        return;
+                      }
+                      finishReject(
+                        new Error(
+                          `Stale fullSync sequence: expected >= ${sequence}, got ${internal.sequence}`
+                        )
+                      );
                     }).catch((error) => {
                       finishReject(error);
                     });
                   }, clientExecuteSyncTimeoutMs);
                 });
               }
-              if (result?.$$Error) {
+              if (isTransportErrorEnvelope(result)) {
+                done?.(result);
+                throw new Error(result.message);
+              }
+              if (isLegacyTransportErrorEnvelope(result)) {
                 done?.(result);
                 throw new Error(result.$$Error);
               }
@@ -556,7 +677,11 @@ var handleState = (store, internal, options) => {
         }
       }
     }
-    return [internal.rootState, patches, inversePatches];
+    return [
+      internal.rootState,
+      finalPatches.patches,
+      finalPatches.inversePatches
+    ];
   }) => {
     if (store.share === "client") {
       throw new Error(
@@ -665,6 +790,7 @@ var getErrorMessage = (error) => {
   }
   return String(error);
 };
+var transportErrorMarker2 = "__coactionTransportError__";
 var handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
   const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? (0, import_data_transport2.createTransport)(workerType, {
     prefix: store.name
@@ -690,12 +816,19 @@ var handleMainTransport = (store, internal, storeTransport, workerType, checkEna
       if (typeof base !== "function") {
         throw new Error("The function is not found");
       }
-      return [base(...args), internal.sequence];
+      const result = await base(...args);
+      return [result, internal.sequence];
     } catch (error) {
       if (process.env.NODE_ENV === "development") {
         console.error(error);
       }
-      return [{ $$Error: getErrorMessage(error) }, internal.sequence];
+      return [
+        {
+          [transportErrorMarker2]: true,
+          message: getErrorMessage(error)
+        },
+        internal.sequence
+      ];
     }
   });
   transport.listen("fullSync", async () => {
@@ -727,7 +860,7 @@ var create = (createState, options = {}) => {
       listeners: /* @__PURE__ */ new Set()
     };
     const name = options.name ?? defaultName;
-    const shouldTrackName = process.env.NODE_ENV === "development" && share2 === "main";
+    const shouldTrackName = share2 === "main" && process.env.NODE_ENV !== "test";
     const releaseStoreName = () => {
       if (shouldTrackName) {
         namespaceMap.delete(name);

package/dist/index.mjs

@@ -52,23 +52,86 @@ var createAsyncClientStore = (createStore, asyncStoreClientOption) => {
     throw new Error("transport is required");
   }
   asyncClientStore.transport = transport;
-  const fullSync = async () => {
-    const latest = await transport.emit("fullSync");
-    asyncClientStore.apply(JSON.parse(latest.state));
-    internal.sequence = latest.sequence;
+  let syncingPromise = null;
+  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");
+        }
+        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;
+      });
+    }
+    return syncingPromise;
   };
   if (typeof transport.onConnect !== "function") {
     throw new Error("transport.onConnect is required");
   }
-  transport.onConnect?.(async () => {
-    await fullSync();
+  transport.onConnect?.(() => {
+    awaitingReconnectSync = true;
+    reconnectSequenceBaseline = internal.sequence;
+    void fullSync(true).catch((error) => {
+      if (process.env.NODE_ENV === "development") {
+        console.error(error);
+      }
+    });
   });
   transport.listen("update", async (options) => {
-    if (typeof options.sequence === "number" && options.sequence === internal.sequence + 1) {
-      internal.sequence = options.sequence;
-      asyncClientStore.apply(void 0, options.patches);
-    } else {
-      await fullSync();
+    let shouldFullSync = false;
+    let allowLowerSequence = false;
+    try {
+      if (typeof options.sequence !== "number") {
+        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 {
+        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);
+      }
     }
   });
   return wrapStore(asyncClientStore, () => asyncClientStore.getState());
@@ -103,6 +166,7 @@ var isObject = (value) => typeof value === "object" && value !== null;
 var isStateFactory = (value) => typeof value === "function";
 var hasGetState = (value) => (typeof value === "object" || typeof value === "function") && value !== null && typeof value.getState === "function";
 var hasBindState = (value) => isObject(value) && !!value[bindSymbol];
+var formatInvalidStateMessage = (type, stateOrFn, key) => `Invalid state ${type} encountered in makeState: ${key ? `for key ${key}, ` : ""}${typeof stateOrFn}`;
 var getInitialState = (store, createState, internal) => {
   const makeState = (stateOrFn, key) => {
     let state;
@@ -112,9 +176,7 @@ var getInitialState = (store, createState, internal) => {
       state = stateOrFn;
     } else {
       if (process.env.NODE_ENV !== "production") {
-        throw new Error(
-          `Invalid state value encountered in makeState: ${key ? `for key ${key}, ` : ""}${typeof stateOrFn}`
-        );
+        throw new Error(formatInvalidStateMessage("value", stateOrFn, key));
       }
       return {};
     }
@@ -141,6 +203,12 @@ var getInitialState = (store, createState, internal) => {
       delete state[bindSymbol];
       return rawState;
     }
+    if (!isObject(state)) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(formatInvalidStateMessage("result", state, key));
+      }
+      return {};
+    }
     return state;
   };
   return store.isSliceStore ? Object.entries(createState).reduce(
@@ -164,6 +232,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;
@@ -179,14 +256,27 @@ var areShallowEqualWithArray = (prev, next) => {
 var mergeObject = (target, source, isSlice) => {
   if (isSlice) {
     if (typeof source === "object" && source !== null) {
-      for (const key in source) {
-        if (typeof source[key] === "object" && source[key] !== null) {
-          Object.assign(target[key], source[key]);
+      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) {
+          assignOwnEnumerable(targetValue, sourceValue);
         }
       }
     }
   } else {
-    Object.assign(target, source);
+    if (typeof source === "object" && source !== null) {
+      assignOwnEnumerable(target, source);
+    }
   }
 };
 var uuid = () => {
@@ -235,6 +325,20 @@ var createSelectorWithArray = createSelectorCreatorWithArray();
 
 // src/getRawState.ts
 var clientExecuteSyncTimeoutMs = 1500;
+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 getRawState = (store, internal, initialState, options) => {
   const rawState = {};
   const handle = (_rawState, _initialState, sliceKey) => {
@@ -313,7 +417,9 @@ var getRawState = (store, internal, initialState, options) => {
               };
             }
             const keys = sliceKey ? [sliceKey, key] : [key];
-            return store.transport.emit("execute", keys, args).then(async ([result, sequence]) => {
+            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(
@@ -353,16 +459,31 @@ var getRawState = (store, internal, initialState, options) => {
                   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;
-                      finishResolve();
+                      if (internal.sequence >= sequence) {
+                        finishResolve();
+                        return;
+                      }
+                      finishReject(
+                        new Error(
+                          `Stale fullSync sequence: expected >= ${sequence}, got ${internal.sequence}`
+                        )
+                      );
                     }).catch((error) => {
                       finishReject(error);
                     });
                   }, clientExecuteSyncTimeoutMs);
                 });
               }
-              if (result?.$$Error) {
+              if (isTransportErrorEnvelope(result)) {
+                done?.(result);
+                throw new Error(result.message);
+              }
+              if (isLegacyTransportErrorEnvelope(result)) {
                 done?.(result);
                 throw new Error(result.$$Error);
               }
@@ -534,7 +655,11 @@ var handleState = (store, internal, options) => {
         }
       }
     }
-    return [internal.rootState, patches, inversePatches];
+    return [
+      internal.rootState,
+      finalPatches.patches,
+      finalPatches.inversePatches
+    ];
   }) => {
     if (store.share === "client") {
       throw new Error(
@@ -643,6 +768,7 @@ var getErrorMessage = (error) => {
   }
   return String(error);
 };
+var transportErrorMarker2 = "__coactionTransportError__";
 var handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
   const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? createTransport2(workerType, {
     prefix: store.name
@@ -668,12 +794,19 @@ var handleMainTransport = (store, internal, storeTransport, workerType, checkEna
       if (typeof base !== "function") {
         throw new Error("The function is not found");
       }
-      return [base(...args), internal.sequence];
+      const result = await base(...args);
+      return [result, internal.sequence];
     } catch (error) {
       if (process.env.NODE_ENV === "development") {
         console.error(error);
       }
-      return [{ $$Error: getErrorMessage(error) }, internal.sequence];
+      return [
+        {
+          [transportErrorMarker2]: true,
+          message: getErrorMessage(error)
+        },
+        internal.sequence
+      ];
     }
   });
   transport.listen("fullSync", async () => {
@@ -705,7 +838,7 @@ var create = (createState, options = {}) => {
       listeners: /* @__PURE__ */ new Set()
     };
     const name = options.name ?? defaultName;
-    const shouldTrackName = process.env.NODE_ENV === "development" && share2 === "main";
+    const shouldTrackName = share2 === "main" && process.env.NODE_ENV !== "test";
     const releaseStoreName = () => {
       if (shouldTrackName) {
         namespaceMap.delete(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coaction",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A sleek JavaScript library designed for high-performance and multithreading web apps.",
   "keywords": [
     "coaction"