@solidjs/signals 0.10.7 → 0.11.0

package/dist/dev.js

@@ -601,8 +601,8 @@ function handleAsync(el, result, setter) {
       if (!equals || !equals(value, prevValue)) {
         el._value = value;
         el._time = clock;
-        if (el._pendingValueComputed) {
-          setSignal(el._pendingValueComputed, value);
+        if (el._latestValueComputed) {
+          setSignal(el._latestValueComputed, value);
         }
         insertSubs(el, true);
       }
@@ -869,7 +869,7 @@ function formatId(prefix, id) {
   return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
 }
 function getObserver() {
-  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
+  if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
   return tracking ? context : null;
 }
 function getOwner() {
@@ -1010,7 +1010,7 @@ function trackedEffect(fn, options) {
       }
     },
     undefined,
-    { ...options, lazy: true, pureWrite: true }
+    { ...options, lazy: true }
   );
   node._cleanup = undefined;
   node._modified = true;
@@ -1028,7 +1028,7 @@ let stale = false;
 let refreshing = false;
 let pendingCheckActive = false;
 let foundPending = false;
-let pendingReadActive = false;
+let latestReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
 let snapshotCaptureActive = false;
@@ -1306,9 +1306,25 @@ function optimisticComputed(fn, initialValue, options) {
 function isEqual(a, b) {
   return a === b;
 }
+let strictRead = false;
+function setStrictRead(v) {
+  const prev = strictRead;
+  strictRead = v;
+  return prev;
+}
 function untrack(fn) {
-  if (!tracking) return fn();
+  if (!tracking && !strictRead) return fn();
   tracking = false;
+  if (strictRead) {
+    const prev = strictRead;
+    strictRead = false;
+    try {
+      return fn();
+    } finally {
+      tracking = true;
+      strictRead = prev;
+    }
+  }
   try {
     return fn();
   } finally {
@@ -1316,10 +1332,10 @@ function untrack(fn) {
   }
 }
 function read(el) {
-  if (pendingReadActive) {
-    const pendingComputed = getPendingValueComputed(el);
-    const prevPending = pendingReadActive;
-    pendingReadActive = false;
+  if (latestReadActive) {
+    const pendingComputed = getLatestValueComputed(el);
+    const prevPending = latestReadActive;
+    latestReadActive = false;
     let value;
     try {
       value = read(pendingComputed);
@@ -1327,7 +1343,7 @@ function read(el) {
       if (!context && e instanceof NotReadyError) return el._value;
       throw e;
     } finally {
-      pendingReadActive = prevPending;
+      latestReadActive = prevPending;
     }
     if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
     if (stale && currentOptimisticLane && pendingComputed._optimisticLane) {
@@ -1406,6 +1422,10 @@ function read(el) {
       return snapshot;
     }
   }
+  if (strictRead && !tracking)
+    console.warn(
+      `Untracked reactive read in ${strictRead}. This value won't update — use untrack() if intentional.`
+    );
   return !c ||
     currentOptimisticLane !== null ||
     el._pendingValue === NOT_PENDING ||
@@ -1414,7 +1434,7 @@ function read(el) {
     : el._pendingValue;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && context && el._firewall !== context)
+  if (!el._pureWrite && !leafEffectActive && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
@@ -1453,8 +1473,8 @@ function setSignal(el, v) {
     el._pendingValue = v;
   }
   updatePendingSignal(el);
-  if (el._pendingValueComputed) {
-    setSignal(el._pendingValueComputed, v);
+  if (el._latestValueComputed) {
+    setSignal(el._latestValueComputed, v);
   }
   el._time = clock;
   insertSubs(el, isOptimistic);
@@ -1515,21 +1535,21 @@ function updatePendingSignal(el) {
     }
   }
 }
-function getPendingValueComputed(el) {
-  if (!el._pendingValueComputed) {
-    const prevPending = pendingReadActive;
-    pendingReadActive = false;
+function getLatestValueComputed(el) {
+  if (!el._latestValueComputed) {
+    const prevPending = latestReadActive;
+    latestReadActive = false;
     const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
     const prevContext = context;
     context = null;
-    el._pendingValueComputed = optimisticComputed(() => read(el));
-    el._pendingValueComputed._parentSource = el;
+    el._latestValueComputed = optimisticComputed(() => read(el));
+    el._latestValueComputed._parentSource = el;
     context = prevContext;
     pendingCheckActive = prevCheck;
-    pendingReadActive = prevPending;
+    latestReadActive = prevPending;
   }
-  return el._pendingValueComputed;
+  return el._latestValueComputed;
 }
 function staleValues(fn, set = true) {
   const prevStale = stale;
@@ -1540,13 +1560,13 @@ function staleValues(fn, set = true) {
     stale = prevStale;
   }
 }
-function pending(fn) {
-  const prevPending = pendingReadActive;
-  pendingReadActive = true;
+function latest(fn) {
+  const prevLatest = latestReadActive;
+  latestReadActive = true;
   try {
     return fn();
   } finally {
-    pendingReadActive = prevPending;
+    latestReadActive = prevLatest;
   }
 }
 function isPending(fn) {
@@ -2121,6 +2141,10 @@ const storeTraps = {
         );
       }
     }
+    if (strictRead && !tracking && typeof property === "string")
+      console.warn(
+        `Untracked reactive read in ${strictRead}. This value won't update — use untrack() if intentional.`
+      );
     return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
@@ -2441,6 +2465,71 @@ function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
   }
   return { store: wrappedStore, node: node };
 }
+const DELETE = Symbol("STORE_PATH_DELETE");
+function updatePath(current, args, i = 0) {
+  let part,
+    prev = current;
+  if (i < args.length - 1) {
+    part = args[i];
+    const partType = typeof part;
+    const isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let j = 0; j < part.length; j++) {
+        args[i] = part[j];
+        updatePath(current, args, i);
+      }
+      args[i] = part;
+      return;
+    } else if (isArray && partType === "function") {
+      for (let j = 0; j < current.length; j++) {
+        if (part(current[j], j)) {
+          args[i] = j;
+          updatePath(current, args, i);
+        }
+      }
+      args[i] = part;
+      return;
+    } else if (isArray && partType === "object") {
+      const { from: from = 0, to: to = current.length - 1, by: by = 1 } = part;
+      for (let j = from; j <= to; j += by) {
+        args[i] = j;
+        updatePath(current, args, i);
+      }
+      args[i] = part;
+      return;
+    } else if (i < args.length - 2) {
+      updatePath(current[part], args, i + 1);
+      return;
+    }
+    prev = current[part];
+  }
+  let value = args[args.length - 1];
+  if (typeof value === "function") {
+    value = value(prev);
+    if (value === prev) return;
+  }
+  if (part === undefined && value == undefined) return;
+  if (value === DELETE) {
+    delete current[part];
+  } else if (
+    part === undefined ||
+    (isWrappable(prev) && isWrappable(value) && !Array.isArray(value))
+  ) {
+    const target = part !== undefined ? current[part] : current;
+    const keys = Object.keys(value);
+    for (let i = 0; i < keys.length; i++) target[keys[i]] = value[keys[i]];
+  } else {
+    current[part] = value;
+  }
+}
+const storePath = Object.assign(
+  function storePath(...args) {
+    return state => {
+      updatePath(state, args);
+    };
+  },
+  { DELETE: DELETE }
+);
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
   if (!isWrappable(item)) return item;
@@ -2624,18 +2713,29 @@ function omit(props, ...keys) {
 }
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : undefined;
+  const indexes = map.length > 1;
+  const wrappedMap = options?.name
+    ? (...args) => {
+        setStrictRead(options.name);
+        try {
+          return map(...args);
+        } finally {
+          setStrictRead(false);
+        }
+      }
+    : map;
   return createMemo(
     updateKeyedMap.bind({
       _owner: createOwner(),
       _len: 0,
       _list: list,
       _items: [],
-      _map: map,
+      _map: wrappedMap,
       _mappings: [],
       _nodes: [],
       _key: keyFn,
       _rows: keyFn || options?.keyed === false ? [] : undefined,
-      _indexes: map.length > 1 ? [] : undefined,
+      _indexes: indexes ? [] : undefined,
       _fallback: options?.fallback
     })
   );
@@ -2767,12 +2867,22 @@ function updateKeyedMap() {
   return this._mappings;
 }
 function repeat(count, map, options) {
+  const wrappedMap = options?.name
+    ? i => {
+        setStrictRead(options.name);
+        try {
+          return map(i);
+        } finally {
+          setStrictRead(false);
+        }
+      }
+    : map;
   return updateRepeat.bind({
     _owner: createOwner(),
     _len: 0,
     _offset: 0,
     _count: count,
-    _map: map,
+    _map: wrappedMap,
     _nodes: [],
     _mappings: [],
     _from: options?.from,
@@ -3014,6 +3124,7 @@ export {
   isPending,
   isRefreshing,
   isWrappable,
+  latest,
   mapArray,
   markSnapshotScope,
   merge,
@@ -3021,7 +3132,6 @@ export {
   onCleanup,
   onSettled,
   peekNextChildId,
-  pending,
   reconcile,
   refresh,
   releaseSnapshotScope,
@@ -3030,6 +3140,8 @@ export {
   runWithOwner,
   setContext,
   setSnapshotCapture,
+  setStrictRead,
   snapshot,
+  storePath,
   untrack
 };