solid-js 1.1.6-beta.0 → 1.2.0-beta.0

package/README.md

@@ -115,11 +115,9 @@ For TypeScript remember to set your TSConfig to handle Solid's JSX by:
 ## Documentation
 
 Check out the [Documentation](https://www.solidjs.com/guide) website.
-### Resources
 
-- [Examples](https://github.com/solidjs/solid/blob/main/documentation/resources/examples.md)
-- [Articles](https://github.com/solidjs/solid/blob/main/documentation/resources/articles.md)
-- [Projects](https://github.com/solidjs/solid/blob/main/documentation/resources/projects.md)
+[Examples](https://github.com/solidjs/solid/blob/main/documentation/resources/examples.md)
+
 ## Browser Support
 
 The last 2 versions of modern evergreen browsers and Node LTS.

package/dist/dev.cjs

@@ -145,6 +145,7 @@ const UNOWNED = {
   context: null,
   owner: null
 };
+const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 var Owner = null;
 let Transition = null;
 let Scheduler = null;
@@ -154,7 +155,6 @@ let Updates = null;
 let Effects = null;
 let ExecCount = 0;
 let rootCount = 0;
-const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 function createRoot(fn, detachedOwner) {
   detachedOwner && (Owner = detachedOwner);
   const listener = Listener,
@@ -186,24 +186,12 @@ function createSignal(value, options) {
     pending: NOTPENDING,
     comparator: options.equals || undefined
   };
-  if (Transition && Transition.running) Transition.sources.add(s);
   if (!options.internal) s.name = registerGraph(options.name || hashValue(value), 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 [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);
     }
-    return writeSignal(sig, value);
+    return writeSignal(s, value);
   }];
 }
 function createComputed(fn, value, options) {
@@ -228,18 +216,7 @@ function createMemo(fn, value, options) {
   c.observerSlots = null;
   c.comparator = options.equals || undefined;
   updateComputation(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;
-  };
+  return readSignal.bind(c);
 }
 function createResource(source, fetcher, options) {
   if (arguments.length === 2) {
@@ -253,7 +230,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
   }),
@@ -374,9 +351,8 @@ function createDeferred(source, options) {
 }
 function createSelector(source, fn = equalFn, options) {
   const subs = new Map();
-  let current;
   const node = createComputation(p => {
-    const v = current = source();
+    const v = 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()) {
@@ -392,9 +368,11 @@ 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, current);
+    return fn(key, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
   };
 }
 function batch(fn) {
@@ -407,12 +385,12 @@ function batch(fn) {
     Pending = null;
   }
   runUpdates(() => {
-    for (let i = 0; i < q.length; i++) {
+    for (let i = 0; i < q.length; i += 1) {
       const data = q[i];
       if (data.pending !== NOTPENDING) {
         const pending = data.pending;
         data.pending = NOTPENDING;
-        writeSource(data, pending);
+        writeSignal(data, pending);
       }
     }
   }, false);
@@ -477,14 +455,18 @@ function enableScheduling(scheduler = requestCallback) {
   Scheduler = scheduler;
 }
 function startTransition(fn, cb) {
+  if (Transition && Transition.running) {
+    fn();
+    cb && Transition.cb.push(cb);
+    return;
+  }
   queueMicrotask(() => {
     if (Scheduler || SuspenseContext) {
       Transition || (Transition = {
         sources: new Set(),
-        lookup: new Map(),
-        updated: new Set(),
         effects: [],
         promises: new Set(),
+        disposed: new Set(),
         queue: new Set(),
         running: true,
         cb: []
@@ -511,7 +493,7 @@ function devComponent(Comp, props) {
   c.state = 0;
   c.componentName = Comp.name;
   updateComputation(c);
-  return c.value;
+  return c.tValue !== undefined ? c.tValue : c.value;
 }
 function hashValue(v) {
   const s = new Set();
@@ -570,44 +552,61 @@ let SuspenseContext;
 function getSuspenseContext() {
   return SuspenseContext || (SuspenseContext = createContext({}));
 }
-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);
+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;
   }
-  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 (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);
+    }
   }
-}
-function writeSignal(node, value) {
-  if (typeof value === "function") {
-    value = value(node.pending !== NOTPENDING ? node.pending : node.value);
+  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;
   }
-  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;
   }
-  node.value = 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;
   if (node.observers && node.observers.length) {
     runUpdates(() => {
-      for (let i = 0; i < node.observers.length; i++) {
+      for (let i = 0; i < node.observers.length; i += 1) {
         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 && !o.state) markUpstream(o);
-        o.state = STALE;
+        if (o.observers && (TransitionRunning && !o.tState || !TransitionRunning && !o.state)) markUpstream(o);
+        if (TransitionRunning) o.tState = STALE;else o.state = STALE;
       }
       if (Updates.length > 10e5) {
         Updates = [];
@@ -620,21 +619,20 @@ function writeSource(node, value) {
 }
 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)) {
+    queueMicrotask(() => {
+      runUpdates(() => {
+        Transition && (Transition.running = true);
+        runComputation(node, node.tValue, time);
+      }, false);
+    });
+  }
   Listener = listener;
   Owner = owner;
 }
@@ -647,7 +645,10 @@ function runComputation(node, value, time) {
   }
   if (!node.updatedAt || node.updatedAt <= time) {
     if (node.observers && node.observers.length) {
-      writeSource(node, nextValue);
+      writeSignal(node, nextValue, true);
+    } else if (Transition && Transition.running && node.pure) {
+      Transition.sources.add(node);
+      node.tValue = nextValue;
     } else node.value = nextValue;
     node.updatedAt = time;
   }
@@ -656,7 +657,7 @@ function createComputation(fn, init, pure, state = STALE, options) {
   const c = {
     fn,
     state: state,
-    updatedAt: 0,
+    updatedAt: null,
     owned: null,
     sources: null,
     sourceSlots: null,
@@ -666,25 +667,42 @@ function createComputation(fn, init, pure, state = STALE, options) {
     context: null,
     pure
   };
+  if (Transition && Transition.running) {
+    c.state = 0;
+    c.tState = state;
+  }
   if (Owner === null) console.warn("computations created outside a `createRoot` or `render` will never be disposed");else if (Owner !== UNOWNED) {
-    if (!Owner.owned) Owner.owned = [c];else Owner.owned.push(c);
-    c.name = options && options.name || `${Owner.name || "c"}-${Owner.owned.length}`;
+    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);
+    }
+    c.name = options && options.name || `${Owner.name || "c"}-${(Owner.owned || Owner.tOwned).length}`;
   }
-  if (Transition && Transition.running) Transition.sources.add(c);
   return c;
 }
 function runTop(node) {
-  if (node.state !== STALE) return node.state = 0;
+  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.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
   const ancestors = [node];
   while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
-    if (node.state) ancestors.push(node);
+    if (runningTransition && Transition.disposed.has(node)) return;
+    if (node.state || runningTransition && node.tState) ancestors.push(node);
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     node = ancestors[i];
-    if (node.state === STALE) {
+    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) {
       updateComputation(node);
-    } else if (node.state === PENDING) {
+    } else if (node.state === PENDING || runningTransition && node.tState === PENDING) {
       const updates = Updates;
       Updates = null;
       lookDownstream(node);
@@ -721,11 +739,24 @@ function completeUpdates(wait) {
       setTransPending(true);
       return;
     }
-    const t = Transition;
+    const sources = Transition.sources;
     cbs = Transition.cb;
+    Effects.forEach(e => {
+      "tState" in e && (e.state = e.tState);
+      delete e.tState;
+    });
     Transition = null;
     batch(() => {
-      mergeTransition(t);
+      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;
+      });
       setTransPending(false);
     });
   }
@@ -775,75 +806,24 @@ function runUserEffects(queue) {
 }
 function lookDownstream(node) {
   node.state = 0;
-  for (let i = 0; i < node.sources.length; i++) {
+  for (let i = 0; i < node.sources.length; i += 1) {
     const source = node.sources[i];
     if (source.sources) {
-      if (source.state === STALE) runTop(source);else if (source.state === PENDING) lookDownstream(source);
+      if (source.state === STALE || Transition && Transition.running && source.tState) runTop(source);else if (source.state === PENDING) lookDownstream(source);
     }
   }
 }
 function markUpstream(node) {
-  for (let i = 0; i < node.observers.length; i++) {
+  const runningTransition = Transition && Transition.running;
+  for (let i = 0; i < node.observers.length; i += 1) {
     const o = node.observers[i];
-    if (!o.state) {
-      o.state = PENDING;
+    if (!o.state || runningTransition && !o.tState) {
+      if (runningTransition) o.tState = PENDING;else 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) {
@@ -862,7 +842,13 @@ function cleanNode(node) {
       }
     }
   }
-  if (node.owned) {
+  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) {
     for (i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
     node.owned = null;
   }
@@ -870,9 +856,18 @@ function cleanNode(node) {
     for (i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
     node.cleanups = null;
   }
-  node.state = 0;
+  if (Transition && Transition.running) node.tState = 0;else 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;
@@ -1176,23 +1171,26 @@ const propTraps = {
     return _.keys();
   }
 };
+function resolveSource(s) {
+  return typeof s === "function" ? s() : s;
+}
 function mergeProps(...sources) {
   return new Proxy({
     get(property) {
       for (let i = sources.length - 1; i >= 0; i--) {
-        const v = sources[i][property];
+        const v = resolveSource(sources[i])[property];
         if (v !== undefined) return v;
       }
     },
     has(property) {
       for (let i = sources.length - 1; i >= 0; i--) {
-        if (property in sources[i]) return true;
+        if (property in resolveSource(sources[i])) return true;
       }
       return false;
     },
     keys() {
       const keys = [];
-      for (let i = 0; i < sources.length; i++) keys.push(...Object.keys(sources[i]));
+      for (let i = 0; i < sources.length; i++) keys.push(...Object.keys(resolveSource(sources[i])));
       return [...new Set(keys)];
     }
   }, propTraps);