@solidjs/signals 0.9.1 → 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;
@@ -132,6 +133,7 @@ function adjustHeight(el, heap) {
   }
 }
 const transitions = new Set();
+let optimisticRun = false;
 const dirtyQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 let clock = 0;
@@ -140,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;
@@ -203,6 +205,7 @@ class Queue {
 class GlobalQueue extends Queue {
   _running = false;
   _pendingNodes = [];
+  _optimisticNodes = [];
   static _update;
   static _dispose;
   flush() {
@@ -212,6 +215,7 @@ class GlobalQueue extends Queue {
       runHeap(dirtyQueue, GlobalQueue._update);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
+          let t = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
           this._pendingNodes = [];
           this.stashQueues(activeTransition.queueStash);
@@ -219,20 +223,18 @@ class GlobalQueue extends Queue {
           scheduled = false;
           runTransitionPending(activeTransition.pendingNodes, true);
           activeTransition = null;
+          runOptimistic(t);
           return;
         }
         this._pendingNodes.push(...activeTransition.pendingNodes);
+        this._optimisticNodes !== activeTransition.optimisticNodes &&
+          this._optimisticNodes.push(...activeTransition.optimisticNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
         runTransitionPending(this._pendingNodes, false);
-        dirtyQueue._max >= dirtyQueue._min && runHeap(dirtyQueue, GlobalQueue._update);
       } else if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
-      runPending(this._pendingNodes);
-      while (dirtyQueue._max >= dirtyQueue._min) {
-        runHeap(dirtyQueue, GlobalQueue._update);
-        runPending(this._pendingNodes);
-      }
+      runOptimistic();
       clock++;
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -256,11 +258,14 @@ class GlobalQueue extends Queue {
   initTransition(node) {
     if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = node._transition ?? {
+      activeTransition = node?._transition ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queueStash: { _queues: [[], []], _children: [] }
+        optimisticNodes: [],
+        actions: [],
+        queueStash: { _queues: [[], []], _children: [] },
+        done: false
       };
     }
     transitions.add(activeTransition);
@@ -270,9 +275,47 @@ class GlobalQueue extends Queue {
       n._transition = activeTransition;
       activeTransition.pendingNodes.push(n);
     }
+    for (let i = 0; i < this._optimisticNodes.length; i++) {
+      const n = this._optimisticNodes[i];
+      n._transition = activeTransition;
+      activeTransition.optimisticNodes.push(n);
+    }
     this._pendingNodes = activeTransition.pendingNodes;
+    this._optimisticNodes = activeTransition.optimisticNodes;
+  }
+}
+function notifySubs(node) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height) queue._min = s._sub._height;
+    insertIntoHeap(s._sub, queue);
   }
 }
+function runOptimistic(activeTransition = null) {
+  let resolvePending = !activeTransition;
+  const optimisticNodes = globalQueue._optimisticNodes;
+  optimisticRun = true;
+  for (let i = 0; i < optimisticNodes.length; i++) {
+    const n = optimisticNodes[i];
+    if (
+      !activeTransition &&
+      (!n._transition || n._transition.done) &&
+      n._pendingValue !== NOT_PENDING
+    ) {
+      n._value = n._pendingValue;
+      n._pendingValue = NOT_PENDING;
+    }
+    n._transition = activeTransition;
+    notifySubs(n);
+  }
+  globalQueue._optimisticNodes = [];
+  if (dirtyQueue._max >= dirtyQueue._min) {
+    resolvePending = true;
+    runHeap(dirtyQueue, GlobalQueue._update);
+  }
+  optimisticRun = false;
+  resolvePending && runPending(globalQueue._pendingNodes);
+}
 function runPending(pendingNodes) {
   for (let i = 0; i < pendingNodes.length; i++) {
     const n = pendingNodes[i];
@@ -281,8 +324,6 @@ function runPending(pendingNodes) {
       n._pendingValue = NOT_PENDING;
       if (n._type) n._modified = true;
     }
-    if (n._pendingSignal && n._pendingSignal._pendingValue !== NOT_PENDING)
-      n._pendingSignal._set(n._pendingSignal._pendingValue);
     if (n._fn) GlobalQueue._dispose(n, false, true);
   }
   pendingNodes.length = 0;
@@ -293,10 +334,6 @@ function runTransitionPending(pendingNodes, value) {
     const n = p[i];
     n._transition = activeTransition;
     if (n._pendingCheck) n._pendingCheck._set(value);
-    if (n._pendingSignal && n._pendingSignal._pendingValue !== NOT_PENDING) {
-      n._pendingSignal._set(n._pendingSignal._pendingValue);
-      n._pendingSignal._pendingValue = NOT_PENDING;
-    }
   }
 }
 const globalQueue = new GlobalQueue();
@@ -311,6 +348,8 @@ function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++) queue[i](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) {
@@ -318,13 +357,43 @@ function transitionComplete(transition) {
       break;
     }
   }
+  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;
@@ -334,13 +403,6 @@ let pendingValueCheck = false;
 let pendingCheck = null;
 let refreshing = false;
 let context = null;
-function notifySubs(node) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (queue._min > s._sub._height) queue._min = s._sub._height;
-    insertIntoHeap(s._sub, queue);
-  }
-}
 function recompute(el, create = false) {
   const honoraryOptimistic = el._type && el._transition != activeTransition;
   if (!create) {
@@ -361,7 +423,10 @@ function recompute(el, create = false) {
   el._depsTail = null;
   el._flags = REACTIVE_RECOMPUTING_DEPS;
   el._time = clock;
-  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  let value =
+    el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
+      ? el._value
+      : el._pendingValue;
   let oldHeight = el._height;
   let prevStatusFlags = el._statusFlags;
   let prevError = el._error;
@@ -395,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
@@ -406,21 +471,19 @@ function recompute(el, create = false) {
     if (valueChanged) {
       if (create || el._optimistic || honoraryOptimistic) el._value = value;
       else el._pendingValue = value;
-      if (el._pendingSignal) el._pendingSignal._pendingValue = value;
-    }
-    for (let s = el._subs; s !== null; s = s._nextSub) {
-      const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-      if (s._sub._height < el._height && queue._min > s._sub._height) queue._min = s._sub._height;
-      insertIntoHeap(s._sub, queue);
+      if (el._pendingSignal) setSignal(el._pendingSignal, value);
     }
+    (!el._optimistic || optimisticRun) && notifySubs(el);
   } else if (el._height != oldHeight) {
     for (let s = el._subs; s !== null; s = s._nextSub) {
       insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
-  if ((!create || el._statusFlags & STATUS_PENDING) && !el._optimistic && !el._transition)
+  el._optimistic && !optimisticRun && globalQueue._optimisticNodes.push(el);
+  (!create || el._statusFlags & STATUS_PENDING) &&
+    !el._transition &&
     globalQueue._pendingNodes.push(el);
-  if (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;
@@ -671,7 +734,7 @@ function computed(fn, initialValue, options) {
     }
   }
   if (parent) self._height = parent._height + 1;
-  recompute(self, true);
+  !options?.lazy && recompute(self, true);
   return self;
 }
 function signal(v, options, firewall = null) {
@@ -726,22 +789,10 @@ 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);
       el._pendingSignal._optimistic = true;
-      el._pendingSignal._set = v => setSignal(el._pendingSignal, v);
     }
     pendingValueCheck = false;
     try {
@@ -750,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) {
@@ -767,7 +831,9 @@ function read(el) {
   return !c ||
     el._optimistic ||
     el._pendingValue === NOT_PENDING ||
-    (stale && !pendingCheck && el._transition && activeTransition !== el._transition)
+    (stale &&
+      !pendingCheck &&
+      (c._optimistic || (el._transition && activeTransition !== el._transition)))
     ? el._value
     : el._pendingValue;
 }
@@ -775,12 +841,18 @@ function setSignal(el, v) {
   if (!el._pureWrite && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (typeof v === "function") {
-    v = v(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue);
+    v = v(
+      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
+        ? el._value
+        : el._pendingValue
+    );
   }
   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;
@@ -790,11 +862,11 @@ function setSignal(el, v) {
       if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
       el._pendingValue = v;
     }
-    if (el._pendingSignal) el._pendingSignal._pendingValue = v;
+    if (el._pendingSignal) setSignal(el._pendingSignal, v);
   }
   setStatusFlags(el, STATUS_NONE);
   el._time = clock;
-  notifySubs(el);
+  el._optimistic && !optimisticRun ? globalQueue._optimisticNodes.push(el) : notifySubs(el);
   schedule();
   return v;
 }
@@ -894,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;
@@ -1064,7 +1140,30 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  return {};
+  if (typeof first === "function") {
+    const node = computed(
+      prev => {
+        let n = node || getOwner();
+        n._pendingValue = first(prev);
+        return prev;
+      },
+      second,
+      third
+    );
+    node._optimistic = true;
+    return [read.bind(null, node), setSignal.bind(null, node)];
+  }
+  const o = getOwner();
+  const needsId = o?.id != null;
+  const node = signal(first, needsId ? { id: getNextChildId(o), ...second } : second);
+  node._optimistic = true;
+  return [
+    read.bind(null, node),
+    v => {
+      node._pendingValue = first;
+      return setSignal(node, v);
+    }
+  ];
 }
 function onSettled(callback) {
   let cleanup;
@@ -1079,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);
@@ -1169,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) {
@@ -1222,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"),
@@ -1271,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();
@@ -1284,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);
@@ -1304,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)));
@@ -1332,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;
@@ -1345,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
@@ -1355,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
@@ -1378,7 +1519,7 @@ const storeTraps = {
             nodes,
             property,
             isWrappable(value) ? wrap(value, target) : value,
-            target[STORE_FIREWALL]?.()
+            target[STORE_FIREWALL]
           )
         );
       }
@@ -1392,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];
@@ -1432,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]
@@ -2157,6 +2298,7 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
+  action,
   createBoundary,
   createContext,
   createEffect,