solid-js 1.1.2 → 1.1.6-beta.0

package/dist/solid.js

@@ -141,7 +141,6 @@ const UNOWNED = {
   context: null,
   owner: null
 };
-const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 var Owner = null;
 let Transition = null;
 let Scheduler = null;
@@ -150,6 +149,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,
@@ -180,11 +180,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) {
@@ -209,9 +221,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;
@@ -223,7 +246,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
   }),
@@ -344,8 +367,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()) {
@@ -361,11 +385,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) {
@@ -378,12 +400,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);
@@ -448,27 +470,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;
 }
@@ -491,61 +515,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 = [];
@@ -558,17 +565,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;
 }
@@ -581,10 +592,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;
   }
@@ -593,7 +601,7 @@ function createComputation(fn, init, pure, state = STALE, options) {
   const c = {
     fn,
     state: state,
-    updatedAt: null,
+    updatedAt: 0,
     owned: null,
     sources: null,
     sourceSlots: null,
@@ -603,41 +611,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);
@@ -674,24 +665,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);
     });
   }
@@ -740,24 +718,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) {
@@ -776,13 +805,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;
   }
@@ -790,18 +813,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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "solid-js",
   "description": "A declarative JavaScript library for building user interfaces.",
-  "version": "1.1.2",
+  "version": "1.1.6-beta.0",
   "author": "Ryan Carniato",
   "license": "MIT",
   "homepage": "https://github.com/solidjs/solid#readme",
@@ -120,5 +120,5 @@
     "compiler",
     "performance"
   ],
-  "gitHead": "d4a2ede2deb7e75275fd1a6f821bfd908c80718b"
+  "gitHead": "9333aee148900824222538fed46a75eb996e96ff"
 }

package/store/dist/dev.cjs

@@ -128,8 +128,8 @@ function setProperty(state, property, value) {
   let nodes = getDataNodes(state),
       node;
   (node = nodes[property]) && node.$();
-  if (array && state.length !== len) (node = nodes.length) && node.$(node, undefined);
-  notify && (node = nodes._) && node.$(node, undefined);
+  if (array && state.length !== len) (node = nodes.length) && node.$();
+  notify && (node = nodes._) && node.$();
 }
 function mergeStoreNode(state, value) {
   const keys = Object.keys(value);

package/store/dist/dev.js

@@ -124,8 +124,8 @@ function setProperty(state, property, value) {
   let nodes = getDataNodes(state),
       node;
   (node = nodes[property]) && node.$();
-  if (array && state.length !== len) (node = nodes.length) && node.$(node, undefined);
-  notify && (node = nodes._) && node.$(node, undefined);
+  if (array && state.length !== len) (node = nodes.length) && node.$();
+  notify && (node = nodes._) && node.$();
 }
 function mergeStoreNode(state, value) {
   const keys = Object.keys(value);

package/store/dist/store.cjs

@@ -123,8 +123,8 @@ function setProperty(state, property, value) {
   let nodes = getDataNodes(state),
       node;
   (node = nodes[property]) && node.$();
-  if (array && state.length !== len) (node = nodes.length) && node.$(node, undefined);
-  notify && (node = nodes._) && node.$(node, undefined);
+  if (array && state.length !== len) (node = nodes.length) && node.$();
+  notify && (node = nodes._) && node.$();
 }
 function mergeStoreNode(state, value) {
   const keys = Object.keys(value);

package/store/dist/store.js

@@ -119,8 +119,8 @@ function setProperty(state, property, value) {
   let nodes = getDataNodes(state),
       node;
   (node = nodes[property]) && node.$();
-  if (array && state.length !== len) (node = nodes.length) && node.$(node, undefined);
-  notify && (node = nodes._) && node.$(node, undefined);
+  if (array && state.length !== len) (node = nodes.length) && node.$();
+  notify && (node = nodes._) && node.$();
 }
 function mergeStoreNode(state, value) {
   const keys = Object.keys(value);

package/store/types/store.d.ts

@@ -54,19 +54,25 @@ export declare type StorePathRange = {
     by?: number;
 };
 export declare type ArrayFilterFn<T> = (item: T extends any[] ? T[number] : never, index: number) => boolean;
-export declare type Part<T> = keyof T | Array<keyof T> | StorePathRange | ArrayFilterFn<T>;
-export declare type Next<T, K> = K extends keyof T ? T[K] : K extends Array<keyof T> ? T[K[number]] : T extends any[] ? K extends StorePathRange ? T[number] : K extends ArrayFilterFn<T> ? T[number] : never : never;
+export declare type Part<T> = T extends any[] ? keyof T | Array<keyof T> | ArrayFilterFn<T> | StorePathRange : T extends object ? keyof T | Array<keyof T> : never;
+export declare type NullableNext<T, K> = K extends keyof T ? T[K] : K extends Array<keyof T> ? T[K[number]] : T extends any[] ? K extends StorePathRange ? T[number] : K extends ArrayFilterFn<T> ? T[number] : never : never;
+export declare type Next<T, K> = NonNullable<NullableNext<T, K>>;
 export interface SetStoreFunction<T> {
     <Setter extends StoreSetter<T>>(...args: [Setter]): void;
-    <K1 extends Part<T>, Setter extends StoreSetter<Next<T, K1>>>(...args: [K1, Setter]): void;
-    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, Setter extends StoreSetter<Next<Next<T, K1>, K2>>>(...args: [K1, K2, Setter]): void;
-    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, Setter extends StoreSetter<Next<Next<Next<T, K1>, K2>, K3>>>(...args: [K1, K2, K3, Setter]): void;
-    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, Setter extends StoreSetter<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>>(...args: [K1, K2, K3, K4, Setter]): void;
-    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, Setter extends StoreSetter<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>>(...args: [K1, K2, K3, K4, K5, Setter]): void;
-    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>, Setter extends StoreSetter<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>>(...args: [K1, K2, K3, K4, K5, K6, Setter]): void;
-    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>, K7 extends Part<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>, Setter extends StoreSetter<Next<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>, K7>>>(...args: [K1, K2, K3, K4, K5, K6, K7, Setter]): void;
+    <K1 extends Part<T>, Setter extends StoreSetter<NullableNext<T, K1>>>(...args: [K1, Setter]): void;
+    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, Setter extends StoreSetter<NullableNext<Next<T, K1>, K2>>>(...args: [K1, K2, Setter]): void;
+    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, Setter extends StoreSetter<NullableNext<Next<Next<T, K1>, K2>, K3>>>(...args: [K1, K2, K3, Setter]): void;
+    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, Setter extends StoreSetter<NullableNext<Next<Next<Next<T, K1>, K2>, K3>, K4>>>(...args: [K1, K2, K3, K4, Setter]): void;
+    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, Setter extends StoreSetter<NullableNext<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>>(...args: [K1, K2, K3, K4, K5, Setter]): void;
+    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>, Setter extends StoreSetter<NullableNext<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>>(...args: [K1, K2, K3, K4, K5, K6, Setter]): void;
+    <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>, K7 extends Part<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>, Setter extends StoreSetter<NullableNext<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>, K7>>>(...args: [K1, K2, K3, K4, K5, K6, K7, Setter]): void;
     <K1 extends Part<T>, K2 extends Part<Next<T, K1>>, K3 extends Part<Next<Next<T, K1>, K2>>, K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>, K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>, K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>, K7 extends Part<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>, K8 extends Part<Next<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>, K7>>>(...args: [K1, K2, K3, K4, K5, K6, K7, K8, ...(Part<any> | StoreSetter<any>)[]]): void;
 }
+/**
+ * creates a reactive store that can be read through a proxy object and written with a setter function
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createstore
+ */
 export declare function createStore<T extends StoreNode>(store: T | Store<T>, options?: {
     name?: string;
 }): [get: Store<T>, set: SetStoreFunction<T>];

package/types/jsx.d.ts

@@ -93,6 +93,7 @@ export namespace JSX {
     onBlur?: EventHandlerUnion<T, FocusEvent>;
     onChange?: EventHandlerUnion<T, Event>;
     onInput?: EventHandlerUnion<T, InputEvent>;
+    onBeforeInput?: EventHandlerUnion<T, InputEvent>;
     onReset?: EventHandlerUnion<T, Event>;
     onSubmit?: EventHandlerUnion<
       T,
@@ -180,6 +181,7 @@ export namespace JSX {
     onblur?: EventHandlerUnion<T, FocusEvent>;
     onchange?: EventHandlerUnion<T, Event>;
     oninput?: EventHandlerUnion<T, InputEvent>;
+    onbeforeinput?: EventHandlerUnion<T, InputEvent>;
     onreset?: EventHandlerUnion<T, Event>;
     onsubmit?: EventHandlerUnion<
       T,
@@ -2125,6 +2127,8 @@ export namespace JSX {
     crossorigin?: HTMLCrossorigin;
     decoding?: "sync" | "async" | "auto";
     height?: number | string;
+    ismap?: boolean;
+    isMap?: boolean;
     loading?: "eager" | "lazy";
     referrerpolicy?: HTMLReferrerPolicy;
     referrerPolicy?: HTMLReferrerPolicy;

package/types/reactive/array.d.ts

@@ -1,7 +1,21 @@
 import { Accessor } from "./signal";
+/**
+ * reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ *
+ * similar to `Array.prototype.map`, but gets the index as accessor, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ *
+ * @description https://www.solidjs.com/docs/latest/api#maparray
+ */
 export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
     fallback?: Accessor<any>;
 }): () => U[];
+/**
+ * reactively maps arrays by index instead of value - underlying helper for the `<Index>` control flow
+ *
+ * similar to `Array.prototype.map`, but gets the value as an accessor, transforms only changed items of the original arrays anew and returns an accessor.
+ *
+ * @description https://www.solidjs.com/docs/latest/api#indexarray
+ */
 export declare function indexArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options?: {
     fallback?: Accessor<any>;
 }): () => U[];

package/types/reactive/observable.d.ts

@@ -4,6 +4,16 @@ export declare type ObservableObserver<T> = ((v: T) => void) | {
     error?: (v: any) => void;
     complete?: (v: boolean) => void;
 };
+/**
+ * creates a simple observable from a signal's accessor to be used with the `from` operator of observable libraries like e.g. rxjs
+ * ```typescript
+ * import { from } from "rxjs";
+ * const [s, set] = createSignal(0);
+ * const obsv$ = from(observable(s));
+ * obsv$.subscribe((v) => console.log(v));
+ * ```
+ * description https://www.solidjs.com/docs/latest/api#observable
+ */
 export declare function observable<T>(input: Accessor<T>): {
     [x: number]: () => any;
     subscribe(observer: ObservableObserver<T>): {