solid-js 1.1.2 → 1.1.6-beta.0

package/dist/solid.cjs

@@ -145,7 +145,6 @@ const UNOWNED = {
   context: null,
   owner: null
 };
-const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 var Owner = null;
 let Transition = null;
 let Scheduler = null;
@@ -154,6 +153,7 @@ let Pending = null;
 let Updates = null;
 let Effects = null;
 let ExecCount = 0;
+const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 function createRoot(fn, detachedOwner) {
   detachedOwner && (Owner = detachedOwner);
   const listener = Listener,
@@ -184,11 +184,23 @@ function createSignal(value, options) {
     pending: NOTPENDING,
     comparator: options.equals || undefined
   };
-  return [readSignal.bind(s), value => {
-    if (typeof value === "function") {
-      if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.pending !== NOTPENDING ? s.pending : s.tValue);else value = value(s.pending !== NOTPENDING ? s.pending : s.value);
+  if (Transition && Transition.running) Transition.sources.add(s);
+  return [() => {
+    let sig = s;
+    Transition && Transition.running && (sig = Transition.lookup.get(s) || sig);
+    if (Listener !== null) logRead(sig, Listener);
+    return sig.value;
+  }, value => {
+    let sig = s;
+    if (Transition) {
+      if (Transition.running && !(sig = Transition.lookup.get(s))) {
+        sig = forkSource(s);
+      } else if (!Transition.running) {
+        const other = Transition.lookup.get(s);
+        if (other) writeSignal(other, value);
+      }
     }
-    return writeSignal(s, value);
+    return writeSignal(sig, value);
   }];
 }
 function createComputed(fn, value, options) {
@@ -213,9 +225,20 @@ function createMemo(fn, value, options) {
   c.observerSlots = null;
   c.comparator = options.equals || undefined;
   updateComputation(c);
-  return readSignal.bind(c);
+  return () => {
+    let sig = c;
+    Transition && Transition.running && (sig = Transition.lookup.get(c) || sig);
+    if (c.state && c.sources) {
+      const updates = Updates;
+      Updates = null;
+      c.state === STALE ? updateComputation(c) : lookDownstream(c);
+      Updates = updates;
+    }
+    if (Listener !== null) logRead(sig, Listener);
+    return sig.value;
+  };
 }
-function createResource(source, fetcher, options = {}) {
+function createResource(source, fetcher, options) {
   if (arguments.length === 2) {
     if (typeof fetcher === "object") {
       options = fetcher;
@@ -227,7 +250,7 @@ function createResource(source, fetcher, options = {}) {
     source = true;
   }
   const contexts = new Set(),
-        [s, set] = createSignal(options.initialValue),
+        [s, set] = createSignal(options?.initialValue),
         [track, trigger] = createSignal(undefined, {
     equals: false
   }),
@@ -348,8 +371,9 @@ function createDeferred(source, options) {
 }
 function createSelector(source, fn = equalFn, options) {
   const subs = new Map();
+  let current;
   const node = createComputation(p => {
-    const v = source();
+    const v = current = source();
     for (const key of subs.keys()) if (fn(key, v) || p !== undefined && fn(key, p)) {
       const l = subs.get(key);
       for (const c of l.values()) {
@@ -365,11 +389,9 @@ function createSelector(source, fn = equalFn, options) {
     if (listener = Listener) {
       let l;
       if (l = subs.get(key)) l.add(listener);else subs.set(key, l = new Set([listener]));
-      onCleanup(() => {
-        l.size > 1 ? l.delete(listener) : subs.delete(key);
-      });
+      onCleanup(() => l.size > 1 ? l.delete(listener) : subs.delete(key));
     }
-    return fn(key, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
+    return fn(key, current);
   };
 }
 function batch(fn) {
@@ -382,12 +404,12 @@ function batch(fn) {
     Pending = null;
   }
   runUpdates(() => {
-    for (let i = 0; i < q.length; i += 1) {
+    for (let i = 0; i < q.length; i++) {
       const data = q[i];
       if (data.pending !== NOTPENDING) {
         const pending = data.pending;
         data.pending = NOTPENDING;
-        writeSignal(data, pending);
+        writeSource(data, pending);
       }
     }
   }, false);
@@ -452,27 +474,29 @@ function enableScheduling(scheduler = requestCallback) {
   Scheduler = scheduler;
 }
 function startTransition(fn, cb) {
-  if (Scheduler || SuspenseContext) {
-    Transition || (Transition = {
-      sources: new Set(),
-      effects: [],
-      promises: new Set(),
-      disposed: new Set(),
-      queue: new Set(),
-      running: true,
-      cb: []
-    });
-    cb && Transition.cb.push(cb);
-    Transition.running = true;
-  }
-  batch(fn);
-  if (!Scheduler && !SuspenseContext && cb) cb();
+  queueMicrotask(() => {
+    if (Scheduler || SuspenseContext) {
+      Transition || (Transition = {
+        sources: new Set(),
+        lookup: new Map(),
+        updated: new Set(),
+        effects: [],
+        promises: new Set(),
+        queue: new Set(),
+        running: true,
+        cb: []
+      });
+      cb && Transition.cb.push(cb);
+      Transition.running = true;
+    }
+    batch(fn);
+    if (!Scheduler && !SuspenseContext && cb) cb();
+  });
 }
 function useTransition() {
   return [transPending, startTransition];
 }
 function resumeEffects(e) {
-  Transition && (Transition.running = true);
   Effects.push.apply(Effects, e);
   e.length = 0;
 }
@@ -495,61 +519,44 @@ let SuspenseContext;
 function getSuspenseContext() {
   return SuspenseContext || (SuspenseContext = createContext({}));
 }
-function readSignal() {
-  if (this.state && this.sources) {
-    const updates = Updates;
-    Updates = null;
-    this.state === STALE || Transition && Transition.running && this.tState ? updateComputation(this) : lookDownstream(this);
-    Updates = updates;
+function logRead(node, to) {
+  const sSlot = node.observers ? node.observers.length : 0;
+  if (!to.sources) {
+    to.sources = [node];
+    to.sourceSlots = [sSlot];
+  } else {
+    to.sources.push(node);
+    to.sourceSlots.push(sSlot);
   }
-  if (Listener) {
-    const sSlot = this.observers ? this.observers.length : 0;
-    if (!Listener.sources) {
-      Listener.sources = [this];
-      Listener.sourceSlots = [sSlot];
-    } else {
-      Listener.sources.push(this);
-      Listener.sourceSlots.push(sSlot);
-    }
-    if (!this.observers) {
-      this.observers = [Listener];
-      this.observerSlots = [Listener.sources.length - 1];
-    } else {
-      this.observers.push(Listener);
-      this.observerSlots.push(Listener.sources.length - 1);
-    }
+  if (!node.observers) {
+    node.observers = [to];
+    node.observerSlots = [to.sources.length - 1];
+  } else {
+    node.observers.push(to);
+    node.observerSlots.push(to.sources.length - 1);
   }
-  if (Transition && Transition.running && Transition.sources.has(this)) return this.tValue;
-  return this.value;
-}
-function writeSignal(node, value, isComp) {
-  if (node.comparator) {
-    if (Transition && Transition.running && Transition.sources.has(node)) {
-      if (node.comparator(node.tValue, value)) return value;
-    } else if (node.comparator(node.value, value)) return value;
+}
+function writeSignal(node, value) {
+  if (typeof value === "function") {
+    value = value(node.pending !== NOTPENDING ? node.pending : node.value);
   }
+  return writeSource(node, value);
+}
+function writeSource(node, value) {
+  if (node.comparator && node.comparator(node.value, value)) return value;
   if (Pending) {
     if (node.pending === NOTPENDING) Pending.push(node);
     node.pending = value;
     return value;
   }
-  let TransitionRunning = false;
-  if (Transition) {
-    TransitionRunning = Transition.running;
-    if (TransitionRunning || !isComp && Transition.sources.has(node)) {
-      Transition.sources.add(node);
-      node.tValue = value;
-    }
-    if (!TransitionRunning) node.value = value;
-  } else node.value = value;
+  node.value = value;
   if (node.observers && node.observers.length) {
     runUpdates(() => {
-      for (let i = 0; i < node.observers.length; i += 1) {
+      for (let i = 0; i < node.observers.length; i++) {
         const o = node.observers[i];
-        if (TransitionRunning && Transition.disposed.has(o)) continue;
         if (o.pure) Updates.push(o);else Effects.push(o);
-        if (o.observers && (TransitionRunning && !o.tState || !TransitionRunning && !o.state)) markUpstream(o);
-        if (TransitionRunning) o.tState = STALE;else o.state = STALE;
+        if (o.observers && !o.state) markUpstream(o);
+        o.state = STALE;
       }
       if (Updates.length > 10e5) {
         Updates = [];
@@ -562,17 +569,21 @@ function writeSignal(node, value, isComp) {
 }
 function updateComputation(node) {
   if (!node.fn) return;
+  if (Transition && Transition.sources.has(node)) {
+    Transition.updated.add(node);
+    if (!Transition.running) {
+      return queueMicrotask(() => runUpdates(() => {
+        Transition.running = true;
+        updateComputation(node);
+      }, false));
+    }
+  }
   cleanNode(node);
   const owner = Owner,
         listener = Listener,
         time = ExecCount;
   Listener = Owner = node;
   runComputation(node, node.value, time);
-  if (Transition && !Transition.running && Transition.sources.has(node)) {
-    Transition.running = true;
-    runComputation(node, node.tValue, time);
-    Transition.running = false;
-  }
   Listener = listener;
   Owner = owner;
 }
@@ -585,10 +596,7 @@ function runComputation(node, value, time) {
   }
   if (!node.updatedAt || node.updatedAt <= time) {
     if (node.observers && node.observers.length) {
-      writeSignal(node, nextValue, true);
-    } else if (Transition && Transition.running && node.pure) {
-      Transition.sources.add(node);
-      node.tValue = nextValue;
+      writeSource(node, nextValue);
     } else node.value = nextValue;
     node.updatedAt = time;
   }
@@ -597,7 +605,7 @@ function createComputation(fn, init, pure, state = STALE, options) {
   const c = {
     fn,
     state: state,
-    updatedAt: null,
+    updatedAt: 0,
     owned: null,
     sources: null,
     sourceSlots: null,
@@ -607,41 +615,24 @@ function createComputation(fn, init, pure, state = STALE, options) {
     context: null,
     pure
   };
-  if (Transition && Transition.running) {
-    c.state = 0;
-    c.tState = state;
-  }
   if (Owner === null) ;else if (Owner !== UNOWNED) {
-    if (Transition && Transition.running && Owner.pure) {
-      if (!Owner.tOwned) Owner.tOwned = [c];else Owner.tOwned.push(c);
-    } else {
-      if (!Owner.owned) Owner.owned = [c];else Owner.owned.push(c);
-    }
+    if (!Owner.owned) Owner.owned = [c];else Owner.owned.push(c);
   }
+  if (Transition && Transition.running) Transition.sources.add(c);
   return c;
 }
 function runTop(node) {
-  const runningTransition = Transition && Transition.running;
-  if (!runningTransition && node.state !== STALE) return node.state = 0;
-  if (runningTransition && node.tState !== STALE) return node.tState = 0;
+  if (node.state !== STALE) return node.state = 0;
   if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
   const ancestors = [node];
   while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
-    if (runningTransition && Transition.disposed.has(node)) return;
-    if (node.state || runningTransition && node.tState) ancestors.push(node);
+    if (node.state) ancestors.push(node);
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     node = ancestors[i];
-    if (runningTransition) {
-      let top = node,
-          prev = ancestors[i + 1];
-      while ((top = top.owner) && top !== prev) {
-        if (Transition.disposed.has(top)) return;
-      }
-    }
-    if (node.state === STALE || runningTransition && node.tState === STALE) {
+    if (node.state === STALE) {
       updateComputation(node);
-    } else if (node.state === PENDING || runningTransition && node.tState === PENDING) {
+    } else if (node.state === PENDING) {
       const updates = Updates;
       Updates = null;
       lookDownstream(node);
@@ -678,24 +669,11 @@ function completeUpdates(wait) {
       setTransPending(true);
       return;
     }
-    const sources = Transition.sources;
+    const t = Transition;
     cbs = Transition.cb;
-    Effects.forEach(e => {
-      e.state = STALE;
-      delete e.tState;
-    });
     Transition = null;
     batch(() => {
-      sources.forEach(v => {
-        v.value = v.tValue;
-        if (v.owned) {
-          for (let i = 0, len = v.owned.length; i < len; i++) cleanNode(v.owned[i]);
-        }
-        if (v.tOwned) v.owned = v.tOwned;
-        delete v.tValue;
-        delete v.tOwned;
-        v.tState = 0;
-      });
+      mergeTransition(t);
       setTransPending(false);
     });
   }
@@ -744,24 +722,75 @@ function runUserEffects(queue) {
 }
 function lookDownstream(node) {
   node.state = 0;
-  for (let i = 0; i < node.sources.length; i += 1) {
+  for (let i = 0; i < node.sources.length; i++) {
     const source = node.sources[i];
     if (source.sources) {
-      if (source.state === STALE || Transition && Transition.running && source.tState) runTop(source);else if (source.state === PENDING) lookDownstream(source);
+      if (source.state === STALE) runTop(source);else if (source.state === PENDING) lookDownstream(source);
     }
   }
 }
 function markUpstream(node) {
-  const runningTransition = Transition && Transition.running;
-  for (let i = 0; i < node.observers.length; i += 1) {
+  for (let i = 0; i < node.observers.length; i++) {
     const o = node.observers[i];
-    if (!o.state || runningTransition && !o.tState) {
-      if (runningTransition) o.tState = PENDING;else o.state = PENDING;
+    if (!o.state) {
+      o.state = PENDING;
       if (o.pure) Updates.push(o);else Effects.push(o);
       o.observers && markUpstream(o);
     }
   }
 }
+function forkSource(s, p, slot) {
+  let fork;
+  if (!(fork = Transition.lookup.get(s) || Transition.sources.has(s) && s)) {
+    Transition.lookup.set(s, fork = { ...s
+    });
+    Transition.sources.add(fork);
+    if (fork.observers) {
+      fork.observers = [...new Set(fork.observers)];
+      fork.observerSlots = [];
+      fork.observers.forEach((o, i) => forkSource(o, fork, i));
+    }
+    if (fork.sources) {
+      fork.sources = [p];
+      fork.sourceSlots = [slot];
+      replaceObservers(fork, p, slot, 0);
+    }
+    fork.owned && (fork.owned = null);
+    fork.cleanups && (fork.cleanups = null);
+  } else if ("sources" in fork) {
+    fork.sources.push(p);
+    fork.sourceSlots.push(slot);
+    replaceObservers(fork, p, slot, fork.sources.length - 1);
+  }
+  return fork;
+}
+function replaceObservers(node, source, slot, sourceSlot) {
+  source.observers || (source.observers = []);
+  source.observerSlots || (source.observerSlots = []);
+  source.observers[slot] = node;
+  source.observerSlots[slot] = sourceSlot;
+}
+function mergeTransition(transition) {
+  const reverse = new Map(Array.from(transition.lookup, entry => [entry[1], entry[0]]));
+  transition.lookup.forEach((fork, og) => {
+    if ("sources" in fork && (fork.state || transition.updated.has(fork))) cleanNode(og);
+  });
+  transition.lookup.forEach((fork, og) => {
+    if ("sources" in fork && !fork.state && !transition.updated.has(fork)) return;
+    transition.updated.delete(fork);
+    Object.assign(og, fork);
+    if (og.sources) {
+      og.sourceSlots.forEach((slot, i) => {
+        og.sources[i] = reverse.get(og.sources[i]) || og.sources[i];
+        replaceObservers(og, og.sources[i], slot, i);
+      });
+    }
+  });
+  Effects.forEach((e, i) => {
+    const replace = reverse.get(e);
+    if (replace) Effects[i] = replace;
+  });
+}
 function cleanNode(node) {
   let i;
   if (node.sources) {
@@ -780,13 +809,7 @@ function cleanNode(node) {
       }
     }
   }
-  if (Transition && Transition.running && node.pure) {
-    if (node.tOwned) {
-      for (i = 0; i < node.tOwned.length; i++) cleanNode(node.tOwned[i]);
-      delete node.tOwned;
-    }
-    reset(node, true);
-  } else if (node.owned) {
+  if (node.owned) {
     for (i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
     node.owned = null;
   }
@@ -794,18 +817,9 @@ function cleanNode(node) {
     for (i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
     node.cleanups = null;
   }
-  if (Transition && Transition.running) node.tState = 0;else node.state = 0;
+  node.state = 0;
   node.context = null;
 }
-function reset(node, top) {
-  if (!top) {
-    node.tState = 0;
-    Transition.disposed.add(node);
-  }
-  if (node.owned) {
-    for (let i = 0; i < node.owned.length; i++) reset(node.owned[i]);
-  }
-}
 function handleError(err) {
   const fns = ERROR && lookup(Owner, ERROR);
   if (!fns) throw err;