@solidjs/signals 2.0.0-beta.16 → 2.0.0-beta.17

package/dist/dev.js

@@ -12,6 +12,9 @@ class StatusError extends Error {
     this.source = source;
   }
 }
+function unwrapStatusError(error) {
+  return error instanceof StatusError ? error.cause : error;
+}
 class NoOwnerError extends Error {
   constructor() {
     super("Context can only be accessed under a reactive root.");
@@ -1433,8 +1436,9 @@ function handleAsync(el, result, setter) {
   }
   if (iterator) {
     const it = result[Symbol.asyncIterator]();
-    let hadSyncValue = false;
+    let hadValue = false;
     let completed = false;
+    let initialRead = true;
     cleanup(() => {
       if (completed) return;
       completed = true;
@@ -1445,7 +1449,9 @@ function handleAsync(el, result, setter) {
     });
     const iterate = () => {
       let syncResult,
+        syncError,
         resolved = false,
+        rejected = false,
         isSync = true;
       it.next().then(
         r => {
@@ -1455,30 +1461,46 @@ function handleAsync(el, result, setter) {
             if (r.done) completed = true;
           } else if (el._inFlight !== result) {
             return;
-          } else if (!r.done) asyncWrite(r.value, iterate);
-          else {
+          } else if (!r.done) {
+            hadValue = true;
+            asyncWrite(r.value, iterate);
+          } else {
             completed = true;
-            schedule();
-            flush();
+            if (hadValue) {
+              schedule();
+              flush();
+            } else {
+              asyncWrite(undefined);
+            }
           }
         },
         e => {
-          if (!isSync && el._inFlight === result) {
+          if (isSync) {
+            syncError = e;
+            rejected = true;
+          } else if (el._inFlight === result) {
             completed = true;
             handleError(e);
           }
         }
       );
       isSync = false;
+      if (rejected) {
+        completed = true;
+        handleError(syncError);
+        if (initialRead) throw syncError;
+        return true;
+      }
       if (resolved && !syncResult.done) {
         syncValue = syncResult.value;
-        hadSyncValue = true;
+        hadValue = true;
         return iterate();
       }
       return resolved && syncResult.done;
     };
     const immediatelyDone = iterate();
-    if (!hadSyncValue && !immediatelyDone) {
+    initialRead = false;
+    if (!hadValue && !immediatelyDone) {
       globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
@@ -2632,8 +2654,7 @@ function notifyEffectStatus(status, error) {
 function runEffect(node) {
   if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
   if (node._statusFlags & STATUS_ERROR && node._type === EFFECT_USER) {
-    const err =
-      node._error instanceof StatusError ? (node._error.cause ?? node._error) : node._error;
+    const err = unwrapStatusError(node._error);
     node._prevValue = node._value;
     node._modified = false;
     try {
@@ -2739,6 +2760,9 @@ function trackedEffect(fn, options) {
     console.warn(message);
   }
 }
+const ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE =
+  "[ACTION_CALLED_IN_OWNED_SCOPE] Calling an action inside an owned scope (component, computation) is not allowed. " +
+  "Call it from an event handler or another imperative scope.";
 function restoreTransition(transition, fn) {
   globalQueue.initTransition(transition);
   const result = fn();
@@ -2746,28 +2770,42 @@ function restoreTransition(transition, fn) {
   return result;
 }
 function action(genFn) {
-  return (...args) =>
-    new Promise((resolve, reject) => {
+  return (...args) => {
+    {
+      const owner = getOwner();
+      if (owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)) {
+        emitDiagnostic({
+          code: "ACTION_CALLED_IN_OWNED_SCOPE",
+          kind: "write",
+          severity: "error",
+          message: ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE,
+          ownerId: owner.id,
+          ownerName: owner._name
+        });
+        throw new Error(ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE);
+      }
+    }
+    return new Promise((resolve, reject) => {
       const it = genFn(...args);
       globalQueue.initTransition();
       let ctx = activeTransition;
       ctx._actions.push(it);
-      const done = (v, e) => {
+      const done = (v, e, failed = false) => {
         ctx = currentTransition(ctx);
         const i = ctx._actions.indexOf(it);
         if (i >= 0) ctx._actions.splice(i, 1);
         setActiveTransition(ctx);
         schedule();
-        e ? reject(e) : resolve(v);
+        failed ? reject(e) : resolve(v);
       };
       const step = (v, err) => {
         let r;
         try {
           r = err ? it.throw(v) : it.next(v);
         } catch (e) {
-          return done(undefined, e);
+          return done(undefined, e, true);
         }
-        if (isThenable(r)) return void r.then(run, e => done(undefined, e));
+        if (isThenable(r)) return void r.then(run, e => done(undefined, e, true));
         run(r);
       };
       const run = r => {
@@ -2781,6 +2819,7 @@ function action(genFn) {
       };
       step();
     });
+  };
 }
 function onCleanup(fn) {
   {
@@ -2859,11 +2898,17 @@ function createReaction(effectFn, options) {
   let cl = undefined;
   cleanup(() => cl?.());
   const owner = getOwner();
+  let arm;
   return tracking => {
+    if (arm) {
+      dispose(arm);
+      arm = undefined;
+    }
     runWithOwner(owner, () => {
       effect(
-        () => (tracking(), getOwner()),
+        () => (tracking(), (arm = getOwner())),
         node => {
+          arm = undefined;
           cl?.();
           const cleanup = (effectFn.effect || effectFn)?.();
           if (true && cleanup !== undefined && typeof cleanup !== "function") {
@@ -3554,17 +3599,24 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
   return (nodes[property] = s);
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() &&
-    read(
-      getNode(
-        getNodes(target, STORE_NODE),
-        symbol,
-        undefined,
-        target[STORE_FIREWALL],
-        false,
-        target[STORE_OPTIMISTIC]
-      )
-    );
+  if (!getObserver()) return;
+  read(
+    getNode(
+      getNodes(target, STORE_NODE),
+      symbol,
+      undefined,
+      target[STORE_FIREWALL],
+      false,
+      target[STORE_OPTIMISTIC]
+    )
+  );
+  if (
+    symbol === $TRACK &&
+    !target[STORE_OVERRIDE] &&
+    !target[STORE_OPTIMISTIC_OVERRIDE] &&
+    target[STORE_VALUE][$TARGET]
+  )
+    target[STORE_VALUE][$TRACK];
 }
 function notifySelf(target) {
   const node = target[STORE_NODE]?.[$TRACK];
@@ -3825,9 +3877,14 @@ const storeTraps = {
           ? prevLayer[property] !== $DELETED
           : property in target[STORE_VALUE];
         const value = unwrapStoreValue(rawValue);
+        const index = typeof property === "string" ? Number(property) : -1;
         const isArrayIndexWrite =
-          Array.isArray(state) && property !== "length" && typeof property !== "symbol";
-        const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
+          Array.isArray(state) &&
+          Number.isInteger(index) &&
+          index >= 0 &&
+          index < 4294967295 &&
+          String(index) === property;
+        const nextIndex = isArrayIndexWrite ? index + 1 : 0;
         const len = isArrayIndexWrite && (getOverlayLayer(target, "length") ?? state).length;
         const nextLength = isArrayIndexWrite && nextIndex > len ? nextIndex : undefined;
         if (prev === value && nextLength === undefined) return true;
@@ -4875,9 +4932,6 @@ class CollectionQueue extends Queue {
         this._sources.clear();
       }
     }
-    if (this._collectionType & STATUS_PENDING && flags & STATUS_ERROR) {
-      return super.notify(node, STATUS_ERROR, flags, error);
-    }
     if (this._collectionType & STATUS_PENDING && this._initialized)
       return super.notify(node, type, flags, error);
     if (flags & this._collectionType) {
@@ -4888,7 +4942,7 @@ class CollectionQueue extends Queue {
         this._sources.add(source);
         if (wasEmpty) setSignal(this._disabled, true);
         if (this._collectionType & STATUS_ERROR) {
-          setSignal(this._error, source._error?.cause ?? source._error);
+          setSignal(this._error, unwrapStatusError(source._error));
         }
       }
     }