@solidjs/signals 0.9.2 → 0.9.3

package/dist/dev.js

@@ -34,6 +34,7 @@ const EFFECT_USER = 2;
 const NOT_PENDING = {};
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
+const $REFRESH = Symbol("refresh");
 function actualInsertIntoHeap(n, heap) {
   const parentHeight =
     (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
@@ -141,7 +142,7 @@ let scheduled = false;
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue._running) queueMicrotask(flush);
+  if (!globalQueue._running) Promise.resolve().then(() => queueMicrotask(flush));
 }
 class Queue {
   _parent = null;
@@ -226,6 +227,8 @@ class GlobalQueue extends Queue {
           return;
         }
         this._pendingNodes.push(...activeTransition.pendingNodes);
+        this._optimisticNodes !== activeTransition.optimisticNodes &&
+          this._optimisticNodes.push(...activeTransition.optimisticNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
@@ -255,11 +258,12 @@ class GlobalQueue extends Queue {
   initTransition(node) {
     if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = node._transition ?? {
+      activeTransition = node?._transition ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
         optimisticNodes: [],
+        actions: [],
         queueStash: { _queues: [[], []], _children: [] },
         done: false
       };
@@ -345,6 +349,7 @@ function runQueue(queue, type) {
 }
 function transitionComplete(transition) {
   if (transition.done) return true;
+  if (transition.actions.length) return false;
   let done = true;
   for (let i = 0; i < transition.asyncNodes.length; i++) {
     if (transition.asyncNodes[i]._statusFlags & STATUS_PENDING) {
@@ -355,11 +360,40 @@ function transitionComplete(transition) {
   done && (transition.done = true);
   return done;
 }
-function runInTransition(el, recompute) {
+function runInTransition(transition, fn) {
   const prevTransition = activeTransition;
-  activeTransition = el._transition;
-  recompute(el);
-  activeTransition = prevTransition;
+  try {
+    activeTransition = transition;
+    return fn();
+  } finally {
+    activeTransition = prevTransition;
+  }
+}
+function action(genFn) {
+  return (...args) => {
+    const iterator = genFn(...args);
+    globalQueue.initTransition();
+    let ctx = activeTransition;
+    ctx.actions.push(iterator);
+    const step = input => {
+      let nextValue = iterator.next(input);
+      if (nextValue instanceof Promise) return nextValue.then(process);
+      process(nextValue);
+    };
+    const process = result => {
+      if (result.done) {
+        ctx.actions.splice(ctx.actions.indexOf(iterator), 1);
+        activeTransition = ctx;
+        schedule();
+        flush();
+        return;
+      }
+      const yielded = result.value;
+      if (yielded instanceof Promise) return yielded.then(step);
+      runInTransition(ctx, () => step(yielded));
+    };
+    runInTransition(ctx, () => step());
+  };
 }
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
@@ -426,7 +460,7 @@ function recompute(el, create = false) {
   const valueChanged =
     !el._equals ||
     !el._equals(
-      el._pendingValue === NOT_PENDING || el._optimistic || honoraryOptimistic
+      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition) || honoraryOptimistic
         ? el._value
         : el._pendingValue,
       value
@@ -449,7 +483,7 @@ function recompute(el, create = false) {
   (!create || el._statusFlags & STATUS_PENDING) &&
     !el._transition &&
     globalQueue._pendingNodes.push(el);
-  el._transition && honoraryOptimistic && runInTransition(el, recompute);
+  el._transition && honoraryOptimistic && runInTransition(el._transition, () => recompute(el));
 }
 function handleAsync(el, result, setter) {
   const isObject = typeof result === "object" && result !== null;
@@ -755,17 +789,6 @@ function read(el) {
       }
     }
   }
-  if (pendingCheck) {
-    if (!el._pendingCheck) {
-      el._pendingCheck = signal(false);
-      el._pendingCheck._optimistic = true;
-      el._pendingCheck._set = v => setSignal(el._pendingCheck, v);
-    }
-    const prev = pendingCheck;
-    pendingCheck = null;
-    prev._value = read(el._pendingCheck) || prev._value;
-    pendingCheck = prev;
-  }
   if (pendingValueCheck) {
     if (!el._pendingSignal) {
       el._pendingSignal = signal(el._value);
@@ -778,10 +801,23 @@ function read(el) {
       pendingValueCheck = true;
     }
   }
-  if (el._statusFlags & STATUS_PENDING && !pendingCheck) {
-    if ((c && !stale) || el._statusFlags & STATUS_UNINITIALIZED) throw el._error;
+  const asyncCompute = el._firewall || el;
+  if (pendingCheck) {
+    if (!asyncCompute._pendingCheck) {
+      asyncCompute._pendingCheck = signal(false);
+      asyncCompute._pendingCheck._optimistic = true;
+      asyncCompute._pendingCheck._set = v => setSignal(asyncCompute._pendingCheck, v);
+    }
+    const prev = pendingCheck;
+    pendingCheck = null;
+    prev._value = read(asyncCompute._pendingCheck) || prev._value;
+    pendingCheck = prev;
+  }
+  if (!pendingCheck && asyncCompute._statusFlags & STATUS_PENDING) {
+    if ((c && !stale) || asyncCompute._statusFlags & STATUS_UNINITIALIZED || el._firewall)
+      throw asyncCompute._error;
     else if (c && stale) {
-      setStatusFlags(c, c._statusFlags | 1, el._error);
+      setStatusFlags(c, c._statusFlags | STATUS_PENDING, asyncCompute._error);
     }
   }
   if (el._statusFlags & STATUS_ERROR) {
@@ -814,7 +850,9 @@ function setSignal(el, v) {
   const valueChanged =
     !el._equals ||
     !el._equals(
-      el._pendingValue === NOT_PENDING || el._optimistic ? el._value : el._pendingValue,
+      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
+        ? el._value
+        : el._pendingValue,
       v
     );
   if (!valueChanged && !el._statusFlags) return v;
@@ -928,6 +966,10 @@ function refresh(fn) {
   let prevRefreshing = refreshing;
   refreshing = true;
   try {
+    if (typeof fn !== "function") {
+      recompute(fn[$REFRESH]);
+      return fn;
+    }
     return untrack(fn);
   } finally {
     refreshing = prevRefreshing;
@@ -1136,11 +1178,7 @@ function unwrap(value) {
   return value?.[$TARGET]?.[STORE_NODE] ?? value;
 }
 function getOverrideValue(value, override, nodes, key) {
-  return nodes && key in nodes
-    ? read(nodes[key])
-    : override && key in override
-      ? override[key]
-      : value[key];
+  return override && key in override ? override[key] : value[key];
 }
 function getAllKeys(value, override, next) {
   const keys = getKeys(value, override);
@@ -1226,10 +1264,12 @@ function applyState(next, state, keyFn, all) {
         } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
       }
       if (start < next.length) changed = true;
-    } else if (prevLength && next.length) {
+    } else if (next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
         const item = getOverrideValue(previous, override, nodes, i);
-        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
+        isWrappable(item)
+          ? applyState(next[i], wrap(item, target), keyFn, all)
+          : target[STORE_NODE][i] && setSignal(target[STORE_NODE][i], next[i]);
       }
     }
     if (prevLength !== next.length) {
@@ -1279,36 +1319,74 @@ function reconcile(value, key, all = false) {
 function createProjectionInternal(fn, initialValue = {}, options) {
   let node;
   const wrappedMap = new WeakMap();
+  const wrapper = s => {
+    s[STORE_WRAP] = wrapProjection;
+    s[STORE_LOOKUP] = wrappedMap;
+    Object.defineProperty(s, STORE_FIREWALL, {
+      get() {
+        return node;
+      },
+      configurable: true
+    });
+  };
   const wrapProjection = source => {
     if (wrappedMap.has(source)) return wrappedMap.get(source);
     if (source[$TARGET]?.[STORE_WRAP] === wrapProjection) return source;
-    const wrapped = createStoreProxy(source, storeTraps, {
-      [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap,
-      [STORE_FIREWALL]() {
-        return node;
-      }
-    });
+    const wrapped = createStoreProxy(source, storeTraps, wrapper);
     wrappedMap.set(source, wrapped);
     return wrapped;
   };
   const wrappedStore = wrapProjection(initialValue);
   node = computed(() => {
     const owner = node || getOwner();
-    storeSetter(wrappedStore, s => {
+    storeSetter(new Proxy(wrappedStore, writeTraps), s => {
       const value = handleAsync(owner, fn(s), value => {
-        value !== s &&
+        value !== wrappedStore &&
           value !== undefined &&
           storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
+        setSignal(node, undefined);
       });
-      value !== s && value !== undefined && reconcile(value, options?.key || "id", options?.all)(s);
+      value !== wrappedStore &&
+        value !== undefined &&
+        reconcile(value, options?.key || "id", options?.all)(wrappedStore);
     });
   });
+  node._preventAutoDisposal = true;
   return { store: wrappedStore, node: node };
 }
 function createProjection(fn, initialValue = {}, options) {
   return createProjectionInternal(fn, initialValue, options).store;
 }
+const writeTraps = {
+  get(_, prop) {
+    let value;
+    setWriteOverride(true);
+    try {
+      value = _[prop];
+    } finally {
+      setWriteOverride(false);
+    }
+    return typeof value === "object" && value !== null ? new Proxy(value, writeTraps) : value;
+  },
+  set(_, prop, value) {
+    setWriteOverride(true);
+    try {
+      _[prop] = value;
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  },
+  deleteProperty(_, prop) {
+    setWriteOverride(true);
+    try {
+      delete _[prop];
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  }
+};
 const $TRACK = Symbol("STORE_TRACK"),
   $DEEP = Symbol("STORE_DEEP"),
   $TARGET = Symbol("STORE_TARGET"),
@@ -1328,7 +1406,7 @@ function createStoreProxy(value, traps = storeTraps, extend) {
     newTarget = [];
     newTarget.v = value;
   } else newTarget = { v: value };
-  extend && Object.assign(newTarget, extend);
+  extend && extend(newTarget);
   return (newTarget[$PROXY] = new Proxy(newTarget, traps));
 }
 const storeLookup = new WeakMap();
@@ -1341,6 +1419,13 @@ function wrap(value, target) {
 function isWrappable(obj) {
   return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
+let writeOverride = false;
+function setWriteOverride(value) {
+  writeOverride = value;
+}
+function writeOnly(proxy) {
+  return writeOverride || !!Writing?.has(proxy);
+}
 function getNodes(target, type) {
   let nodes = target[type];
   if (!nodes) target[type] = nodes = Object.create(null);
@@ -1361,9 +1446,7 @@ function getNode(nodes, property, value, firewall, equals = isEqual) {
 }
 function trackSelf(target, symbol = $TRACK) {
   getObserver() &&
-    read(
-      getNode(getNodes(target, STORE_NODE), symbol, undefined, target[STORE_FIREWALL]?.(), false)
-    );
+    read(getNode(getNodes(target, STORE_NODE), symbol, undefined, target[STORE_FIREWALL], false));
 }
 function getKeys(source, override, enumerable = true) {
   const baseKeys = untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)));
@@ -1389,6 +1472,7 @@ const storeTraps = {
   get(target, property, receiver) {
     if (property === $TARGET) return target;
     if (property === $PROXY) return receiver;
+    if (property === $REFRESH) return target[STORE_FIREWALL];
     if (property === $TRACK || property === $DEEP) {
       trackSelf(target, property);
       return receiver;
@@ -1402,7 +1486,7 @@ const storeTraps = {
       const desc = Object.getOwnPropertyDescriptor(storeValue, property);
       if (desc && desc.get) return desc.get.call(receiver);
     }
-    if (Writing?.has(receiver)) {
+    if (writeOnly(receiver)) {
       let value =
         tracked && (overridden || !proxySource)
           ? tracked._pendingValue !== NOT_PENDING
@@ -1412,7 +1496,7 @@ const storeTraps = {
       value === $DELETED && (value = undefined);
       if (!isWrappable(value)) return value;
       const wrapped = wrap(value, target);
-      Writing.add(wrapped);
+      Writing?.add(wrapped);
       return wrapped;
     }
     let value = tracked
@@ -1435,7 +1519,7 @@ const storeTraps = {
             nodes,
             property,
             isWrappable(value) ? wrap(value, target) : value,
-            target[STORE_FIREWALL]?.()
+            target[STORE_FIREWALL]
           )
         );
       }
@@ -1449,12 +1533,12 @@ const storeTraps = {
         ? target[STORE_OVERRIDE][property] !== $DELETED
         : property in target[STORE_VALUE];
     getObserver() &&
-      read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]?.()));
+      read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]));
     return has;
   },
   set(target, property, rawValue) {
     const store = target[$PROXY];
-    if (Writing?.has(target[$PROXY])) {
+    if (writeOnly(store)) {
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
@@ -1489,7 +1573,7 @@ const storeTraps = {
     return true;
   },
   deleteProperty(target, property) {
-    if (Writing?.has(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
+    if (writeOnly(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
       untrack(() => {
         const prev =
           target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
@@ -2214,6 +2298,7 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
+  action,
   createBoundary,
   createContext,
   createEffect,