coaction 1.4.0 → 1.5.0

package/dist/index.mjs

@@ -227,14 +227,22 @@ var isEqual = (x, y) => {
   return x !== x && y !== y;
 };
 var isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+var setOwnEnumerable = (target, key, value) => {
+  if (typeof key === "string" && isUnsafeKey(key)) {
+    return;
+  }
+  target[key] = value;
+};
 var assignOwnEnumerable = (target, source) => {
   for (const key of Object.keys(source)) {
-    if (isUnsafeKey(key)) {
-      continue;
-    }
-    target[key] = source[key];
+    setOwnEnumerable(target, key, source[key]);
   }
 };
+var cloneOwnEnumerable = (source) => {
+  const target = {};
+  assignOwnEnumerable(target, source);
+  return target;
+};
 var areShallowEqualWithArray = (prev, next) => {
   if (prev === null || next === null || prev.length !== next.length) {
     return false;
@@ -326,80 +334,101 @@ var createClientAction = ({
         });
       };
     }
-    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
+    const traceAction = (run) => {
+      try {
+        const result = run();
+        if (result instanceof Promise) {
+          return result.then(
+            (value) => {
+              done?.(value);
+              return value;
+            },
+            (error) => {
+              done?.(error);
+              throw error;
+            }
           );
         }
-        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");
+        done?.(result);
+        return result;
+      } catch (error) {
+        done?.(error);
+        throw error;
+      }
+    };
+    const keys = sliceKey ? [sliceKey, key] : [key];
+    return traceAction(
+      () => 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);
               }
-              store.apply(JSON.parse(next.state));
-              internal.sequence = next.sequence;
+            };
+            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();
-                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;
-    });
+            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");
+                }
+                if (next.sequence >= sequence) {
+                  store.apply(JSON.parse(next.state));
+                  internal.sequence = next.sequence;
+                  finishResolve();
+                  return;
+                }
+                finishReject(
+                  new Error(
+                    `Stale fullSync sequence: expected >= ${sequence}, got ${next.sequence}`
+                  )
+                );
+              }).catch((error) => {
+                finishReject(error);
+              });
+            }, clientExecuteSyncTimeoutMs);
+          });
+        }
+        if (isTransportErrorEnvelope(result)) {
+          throw new Error(result.message);
+        }
+        if (isLegacyTransportErrorEnvelope(result)) {
+          throw new Error(result.$$Error);
+        }
+        return result;
+      })
+    );
   };
 };
 
@@ -430,71 +459,94 @@ var createLocalAction = ({
         id: actionId,
         sliceKey
       });
-      done = (result2) => {
+      done = (result) => {
         store.trace({
           method: key,
           id: actionId,
-          result: result2,
+          result,
           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 traceAction = (run) => {
+      try {
+        const result = run();
+        if (result instanceof Promise) {
+          return result.then(
+            (value) => {
+              done?.(value);
+              return value;
+            },
+            (error) => {
+              done?.(error);
+              throw error;
+            }
+          );
         }
-      };
-      const isDrafted = isDraft(internal.rootState);
-      if (isDrafted) {
-        handleResult();
+        done?.(result);
+        return result;
+      } catch (error) {
+        done?.(error);
+        throw error;
       }
-      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;
+    };
+    const enablePatches = store.transport ?? options.enablePatches;
+    return traceAction(() => {
+      if (internal.mutableInstance && !internal.isBatching && enablePatches) {
+        let result;
+        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 {
+          result = fn.apply(getActionTarget(store, sliceKey), args);
+          if (result instanceof Promise) {
+            asyncResult = result;
+          }
+        } finally {
+          if (!asyncResult) {
+            handleResult(isDrafted);
+          }
         }
-      } finally {
         if (asyncResult) {
-        } else {
-          handleResult(isDrafted);
+          return asyncResult.then(
+            (value) => {
+              handleResult(isDrafted);
+              return value;
+            },
+            (error) => {
+              handleResult(isDrafted);
+              throw error;
+            }
+          );
         }
+        return result;
       }
-      if (asyncResult) {
-        return asyncResult.finally(() => {
-          const result3 = handleResult(isDrafted);
-          done?.(result3);
-          return result3;
+      if (internal.mutableInstance && internal.actMutable) {
+        return internal.actMutable(() => {
+          return fn.apply(getActionTarget(store, sliceKey), args);
         });
       }
-      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;
+      return fn.apply(getActionTarget(store, sliceKey), args);
+    });
   };
 };
 
@@ -549,7 +601,7 @@ var prepareStateDescriptor = ({
       enumerable: true
     });
   } else if (!isComputed) {
-    rawState[key] = descriptor.value;
+    setOwnEnumerable(rawState, key, descriptor.value);
   }
   if (isComputed) {
     if (internal.mutableInstance) {
@@ -604,8 +656,19 @@ var getRawState = (store, internal, initialState, options) => {
   const rawState = {};
   const handle = (_rawState, _initialState, sliceKey) => {
     internal.mutableInstance = internal.toMutableRaw?.(_initialState);
+    const safeDescriptors = {};
     const descriptors = Object.getOwnPropertyDescriptors(_initialState);
-    Object.entries(descriptors).forEach(([key, descriptor]) => {
+    Reflect.ownKeys(descriptors).forEach((key) => {
+      if (typeof key === "string" && isUnsafeKey(key)) {
+        return;
+      }
+      safeDescriptors[key] = Reflect.get(descriptors, key);
+    });
+    Reflect.ownKeys(safeDescriptors).forEach((key) => {
+      const descriptor = safeDescriptors[key];
+      if (typeof descriptor === "undefined") {
+        return;
+      }
       if (Object.prototype.hasOwnProperty.call(descriptor, "value")) {
         if (typeof descriptor.value !== "function") {
           prepareStateDescriptor({
@@ -615,7 +678,12 @@ var getRawState = (store, internal, initialState, options) => {
             rawState: _rawState,
             sliceKey
           });
-        } else if (store.share === "client") {
+          return;
+        }
+        if (typeof key !== "string") {
+          return;
+        }
+        if (store.share === "client") {
           descriptor.value = createClientAction({
             clientExecuteSyncTimeoutMs,
             internal,
@@ -635,14 +703,22 @@ var getRawState = (store, internal, initialState, options) => {
         }
       }
     });
-    const slice = Object.defineProperties({}, descriptors);
+    const slice = Object.defineProperties({}, safeDescriptors);
     return slice;
   };
   if (store.isSliceStore) {
     internal.module = {};
     Object.entries(initialState).forEach(([key, value]) => {
-      rawState[key] = {};
-      internal.module[key] = handle(rawState[key], value, key);
+      if (isUnsafeKey(key)) {
+        return;
+      }
+      const sliceRawState = {};
+      setOwnEnumerable(rawState, key, sliceRawState);
+      setOwnEnumerable(
+        internal.module,
+        key,
+        handle(sliceRawState, value, key)
+      );
     });
   } else {
     internal.module = handle(rawState, initialState);
@@ -704,13 +780,6 @@ var handleState = (store, internal, options) => {
     const finalPatches = store.patch ? store.patch({ patches, inversePatches }) : { patches, inversePatches };
     if (finalPatches.patches.length) {
       store.apply(internal.rootState, finalPatches.patches);
-      if (!internal.mutableInstance) {
-        if (internal.updateImmutable) {
-          internal.updateImmutable(internal.rootState);
-        } else {
-          internal.listeners.forEach((listener) => listener());
-        }
-      }
     }
     return [
       internal.rootState,
@@ -726,6 +795,9 @@ var handleState = (store, internal, options) => {
     if (internal.isBatching) {
       throw new Error("setState cannot be called within the updater");
     }
+    if (next === null) {
+      return [];
+    }
     internal.isBatching = true;
     if (!store.share && !options.enablePatches && !internal.mutableInstance) {
       if (typeof next === "function") {
@@ -744,13 +816,28 @@ var handleState = (store, internal, options) => {
           throw error;
         }
       } else {
-        const copy = {};
-        const rootState = internal.rootState;
-        for (const key of Object.keys(rootState)) {
-          copy[key] = rootState[key];
-        }
-        for (const key of Object.keys(next)) {
-          copy[key] = next[key];
+        const copy = cloneOwnEnumerable(internal.rootState);
+        if (store.isSliceStore) {
+          for (const key of Object.keys(next)) {
+            if (!Object.prototype.hasOwnProperty.call(copy, key)) {
+              continue;
+            }
+            const sourceValue = next[key];
+            if (typeof sourceValue !== "object" || sourceValue === null) {
+              continue;
+            }
+            const targetValue = copy[key];
+            if (typeof targetValue !== "object" || targetValue === null) {
+              continue;
+            }
+            const sliceCopy = cloneOwnEnumerable(
+              targetValue
+            );
+            mergeObject(sliceCopy, sourceValue);
+            setOwnEnumerable(copy, key, sliceCopy);
+          }
+        } else {
+          mergeObject(copy, next);
         }
         internal.rootState = copy;
       }
@@ -878,23 +965,55 @@ var handleMainTransport = (store, internal, storeTransport, workerType, checkEna
 // src/create.ts
 var namespaceMap = /* @__PURE__ */ new Map();
 var hasWarnedAmbiguousFunctionMap = false;
+var isMainWorkerType = (workerType) => workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal";
+var isClientWorkerType = (workerType) => workerType === "SharedWorkerClient" || workerType === "WebWorkerClient";
+var validateCreateModeOptions = (options) => {
+  const storeTransport = options.transport;
+  const clientTransport = options.clientTransport;
+  const worker = options.worker;
+  const explicitWorkerType = options.workerType;
+  if (storeTransport && clientTransport) {
+    throw new Error(
+      "transport and clientTransport cannot be used together, please use one authority model per store."
+    );
+  }
+  if (storeTransport && worker) {
+    throw new Error(
+      "transport and worker cannot be used together, please use one authority model per store."
+    );
+  }
+  if (clientTransport && worker) {
+    throw new Error(
+      "clientTransport and worker cannot be used together, please use one client transport source."
+    );
+  }
+  if (isMainWorkerType(explicitWorkerType) && (clientTransport || worker)) {
+    throw new Error(
+      "main workerType cannot be combined with client transport settings."
+    );
+  }
+  if (isClientWorkerType(explicitWorkerType) && storeTransport) {
+    throw new Error("client workerType cannot be combined with transport.");
+  }
+};
 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.`
+    [
+      `sliceMode: 'auto' inferred slices from an object of functions.`,
+      `This shape is ambiguous with a single store that only contains methods.`,
+      `Use create({ ping() {} }, { sliceMode: 'single' }) for a plain method store,`,
+      `or create({ counter: (set) => ({ count: 0 }) }, { sliceMode: 'slices' }) for slices.`
+    ].join(" ")
   );
 };
 var create = (createState, options = {}) => {
   const checkEnablePatches = Object.hasOwnProperty.call(options, "enablePatches") && !options.enablePatches;
+  validateCreateModeOptions(options);
   const workerType = options.workerType ?? WorkerType;
-  if (process.env.NODE_ENV === "development" && options.transport && options.clientTransport) {
-    throw new Error(
-      `transport and clientTransport cannot be used together, please use one of them.`
-    );
-  }
   const storeTransport = options.transport;
   const share = workerType === "WebWorkerInternal" || workerType === "SharedWorkerInternal" || storeTransport ? "main" : void 0;
   const createStore = ({ share: share2 }) => {

package/package.json

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