@solidjs/signals 2.0.0-beta.11 → 2.0.0-beta.12

package/dist/prod.js

@@ -3376,8 +3376,9 @@ function mapArray(e, t, n) {
     et: [],
     tt: i,
     nt: i || n?.keyed === false ? [] : undefined,
-    it: r ? [] : undefined,
-    rt: n?.fallback
+    it: r && n?.keyed !== false ? [] : undefined,
+    rt: n?.keyed === false,
+    st: n?.fallback
   };
   const u = computed(updateKeyedMap.bind(o));
   o.Ze.u = u;
@@ -3393,20 +3394,25 @@ function updateKeyedMap() {
     let n,
       i,
       r = this.nt
-        ? () => {
-            this.nt[i] = signal(e[i], pureOptions);
-            this.it && (this.it[i] = signal(i, pureOptions));
-            return this.Xe(accessor(this.nt[i]), this.it ? accessor(this.it[i]) : undefined);
-          }
+        ? this.rt
+          ? () => {
+              this.nt[i] = signal(e[i], pureOptions);
+              return this.Xe(accessor(this.nt[i]), i);
+            }
+          : () => {
+              this.nt[i] = signal(e[i], pureOptions);
+              this.it && (this.it[i] = signal(i, pureOptions));
+              return this.Xe(accessor(this.nt[i]), this.it ? accessor(this.it[i]) : undefined);
+            }
         : this.it
           ? () => {
               const t = e[i];
               this.it[i] = signal(i, pureOptions);
-              return this.Xe(() => t, accessor(this.it[i]));
+              return this.Xe(t, accessor(this.it[i]));
             }
           : () => {
               const t = e[i];
-              return this.Xe(() => t);
+              return this.Xe(t);
             };
     if (t === 0) {
       if (this.qe !== 0) {
@@ -3418,8 +3424,8 @@ function updateKeyedMap() {
         this.nt && (this.nt = []);
         this.it && (this.it = []);
       }
-      if (this.rt && !this.Je[0]) {
-        this.Je[0] = runWithOwner((this.et[0] = createOwner()), this.rt);
+      if (this.st && !this.Je[0]) {
+        this.Je[0] = runWithOwner((this.et[0] = createOwner()), this.st);
       }
     } else if (this.qe === 0) {
       if (this.et[0]) this.et[0].dispose();
@@ -3510,21 +3516,21 @@ function repeat(e, t, n) {
     updateRepeat.bind({
       Ze: createOwner(),
       qe: 0,
-      st: 0,
-      ot: e,
+      ot: 0,
+      ut: e,
       Xe: i,
       et: [],
       Je: [],
-      ut: n?.from,
-      rt: n?.fallback
+      lt: n?.from,
+      st: n?.fallback
     })
   );
   r._e &= ~CONFIG_AUTO_DISPOSE;
   return accessor(r);
 }
 function updateRepeat() {
-  const e = this.ot();
-  const t = this.ut?.() || 0;
+  const e = this.ut();
+  const t = this.lt?.() || 0;
   runWithOwner(this.Ze, () => {
     if (e === 0) {
       if (this.qe !== 0) {
@@ -3533,23 +3539,23 @@ function updateRepeat() {
         this.Je = [];
         this.qe = 0;
       }
-      if (this.rt && !this.Je[0]) {
-        this.Je[0] = runWithOwner((this.et[0] = createOwner()), this.rt);
+      if (this.st && !this.Je[0]) {
+        this.Je[0] = runWithOwner((this.et[0] = createOwner()), this.st);
       }
       return;
     }
     const n = t + e;
-    const i = this.st + this.qe;
+    const i = this.ot + this.qe;
     if (this.qe === 0 && this.et[0]) this.et[0].dispose();
-    for (let e = n; e < i; e++) this.et[e - this.st].dispose();
-    if (this.st < t) {
-      let e = this.st;
+    for (let e = n; e < i; e++) this.et[e - this.ot].dispose();
+    if (this.ot < t) {
+      let e = this.ot;
       while (e < t && e < this.qe) this.et[e++].dispose();
-      this.et.splice(0, t - this.st);
-      this.Je.splice(0, t - this.st);
-    } else if (this.st > t) {
-      let n = i - this.st - 1;
-      let r = this.st - t;
+      this.et.splice(0, t - this.ot);
+      this.Je.splice(0, t - this.ot);
+    } else if (this.ot > t) {
+      let n = i - this.ot - 1;
+      let r = this.ot - t;
       this.et.length = this.Je.length = e;
       while (n >= r) {
         this.et[n] = this.et[n - r];
@@ -3564,7 +3570,7 @@ function updateRepeat() {
       this.Je[e - t] = runWithOwner((this.et[e - t] = createOwner()), () => this.Xe(e));
     }
     this.Je = this.Je.slice(0, e);
-    this.st = t;
+    this.ot = t;
     this.qe = e;
   });
   return this.Je;
@@ -3577,10 +3583,10 @@ function boundaryComputed(e, t) {
   n.xe = (e, t) => {
     const i = e !== undefined ? e : n.he;
     const r = t !== undefined ? t : n.Re;
-    n.he &= ~n.lt;
-    n.te.notify(n, n.lt, i, r);
+    n.he &= ~n.ct;
+    n.te.notify(n, n.ct, i, r);
   };
-  n.lt = t;
+  n.ct = t;
   n._e &= ~CONFIG_AUTO_DISPOSE;
   recompute(n, true);
   return n;
@@ -3603,52 +3609,52 @@ function isRevealController(e) {
   return e instanceof RevealController;
 }
 function isSlotReady(e) {
-  return isRevealController(e) ? e.isReady() : e.ct.size === 0 && !e.ft;
+  return isRevealController(e) ? e.isReady() : e.ft.size === 0 && !e.Et;
 }
 function isSlotMinimallyReady(e) {
   return isRevealController(e) ? e.isMinimallyReady() : isSlotReady(e);
 }
 function setSlotState(e, t, n, i) {
-  setSignal(e.Et, n);
-  setSignal(e.St, i);
+  setSignal(e.St, n);
+  setSignal(e.Tt, i);
   if (isRevealController(e)) {
-    if (!n && e.Tt === t) e.Tt = undefined;
+    if (!n && e.dt === t) e.dt = undefined;
     return e.evaluate(n, i);
   }
-  if (!n && e.dt === t && e.Ot) e.dt = undefined;
+  if (!n && e.Ot === t && e._t) e.Ot = undefined;
 }
 class RevealController {
-  _t;
   Rt;
-  It = [];
-  Tt;
-  Et = signal(false, { ownedWrite: true, Ye: true });
+  It;
+  ht = [];
+  dt;
   St = signal(false, { ownedWrite: true, Ye: true });
-  ht = true;
+  Tt = signal(false, { ownedWrite: true, Ye: true });
   Nt = true;
-  At = false;
+  At = true;
+  Ct = false;
   constructor(e, t) {
-    this._t = e;
-    this.Rt = t;
+    this.Rt = e;
+    this.It = t;
   }
-  Ct(e) {
-    for (let t = 0; t < this.It.length; t++) {
-      const n = this.It[t];
-      if ((isRevealController(n) ? n.Tt : n.dt) !== this) continue;
+  Pt(e) {
+    for (let t = 0; t < this.ht.length; t++) {
+      const n = this.ht[t];
+      if ((isRevealController(n) ? n.dt : n.Ot) !== this) continue;
       if (e(n) === false) return false;
     }
     return true;
   }
   isReady() {
-    return this.Ct(isSlotReady);
+    return this.Pt(isSlotReady);
   }
   isMinimallyReady() {
-    const e = untrack(this._t);
+    const e = untrack(this.Rt);
     if (e === "together") return this.isReady();
     if (e === "natural") {
       let e = false;
       let t = false;
-      this.Ct(n => {
+      this.Pt(n => {
         e = true;
         if (isSlotMinimallyReady(n)) {
           t = true;
@@ -3658,58 +3664,58 @@ class RevealController {
       return !e || t;
     }
     let t = true;
-    this.Ct(e => {
+    this.Pt(e => {
       t = isSlotMinimallyReady(e);
       return false;
     });
     return t;
   }
   register(e) {
-    if (this.It.includes(e)) return;
-    this.It.push(e);
-    const t = untrack(this._t);
-    (setSignal(e.Et, true), setSignal(e.St, t === "sequential" ? !!untrack(this.Rt) : false));
+    if (this.ht.includes(e)) return;
+    this.ht.push(e);
+    const t = untrack(this.Rt);
+    (setSignal(e.St, true), setSignal(e.Tt, t === "sequential" ? !!untrack(this.It) : false));
     untrack(() => this.evaluate());
   }
   unregister(e) {
-    const t = this.It.indexOf(e);
-    if (t >= 0) this.It.splice(t, 1);
+    const t = this.ht.indexOf(e);
+    if (t >= 0) this.ht.splice(t, 1);
     untrack(() => this.evaluate());
   }
   evaluate(e, t) {
-    if (this.At) return;
-    this.At = true;
-    const n = this.ht;
-    const i = this.Nt;
+    if (this.Ct) return;
+    this.Ct = true;
+    const n = this.Nt;
+    const i = this.At;
     try {
-      const n = e ?? read(this.Et),
-        i = untrack(this._t),
-        r = i === "sequential" && !!untrack(this.Rt),
+      const n = e ?? read(this.St),
+        i = untrack(this.Rt),
+        r = i === "sequential" && !!untrack(this.It),
         s = t ?? r;
       if (n) {
-        this.Ct(e => setSlotState(e, this, true, s));
+        this.Pt(e => setSlotState(e, this, true, s));
       } else if (i === "natural") {
-        this.Ct(e => {
+        this.Pt(e => {
           if (isRevealController(e)) {
+            setSignal(e.Tt, false);
             setSignal(e.St, false);
-            setSignal(e.Et, false);
             e.evaluate(false, false);
           } else {
             setSlotState(e, this, !isSlotReady(e), false);
           }
         });
       } else if (i === "together") {
-        const e = this.Ct(isSlotMinimallyReady);
-        this.Ct(t => setSlotState(t, this, !e, false));
+        const e = this.Pt(isSlotMinimallyReady);
+        this.Pt(t => setSlotState(t, this, !e, false));
       } else {
         let e = false;
-        this.Ct(t => {
+        this.Pt(t => {
           if (e) return setSlotState(t, this, true, r);
           if (isSlotReady(t)) return setSlotState(t, this, false, false);
           e = true;
           if (isRevealController(t)) {
+            setSignal(t.Tt, false);
             setSignal(t.St, false);
-            setSignal(t.Et, false);
             t.evaluate(false, false);
           } else {
             setSlotState(t, this, true, false);
@@ -3717,96 +3723,96 @@ class RevealController {
         });
       }
     } finally {
-      this.ht = this.isReady();
-      this.Nt = this.isMinimallyReady();
-      this.At = false;
+      this.Nt = this.isReady();
+      this.At = this.isMinimallyReady();
+      this.Ct = false;
     }
-    if (this.Tt && (n !== this.ht || i !== this.Nt)) this.Tt.evaluate();
+    if (this.dt && (n !== this.Nt || i !== this.At)) this.dt.evaluate();
   }
 }
 class CollectionQueue extends Queue {
-  Pt;
-  ct = new Set();
   gt;
-  ft = true;
-  Et = signal(false, { ownedWrite: true, Ye: true });
-  St = signal(false, { ownedWrite: true, Ye: true });
-  dt;
-  Ot = false;
+  ft = new Set();
   Dt;
-  yt = ON_INIT;
+  Et = true;
+  St = signal(false, { ownedWrite: true, Ye: true });
+  Tt = signal(false, { ownedWrite: true, Ye: true });
+  Ot;
+  _t = false;
+  yt;
+  vt = ON_INIT;
   constructor(e) {
     super();
-    this.Pt = e;
+    this.gt = e;
   }
   run(e) {
-    if (!e || (read(this.Et) && (!_revealUsed || read(this.St)))) return;
+    if (!e || (read(this.St) && (!_revealUsed || read(this.Tt)))) return;
     return super.run(e);
   }
   notify(e, t, n, i) {
-    if (!(t & this.Pt)) return super.notify(e, t, n, i);
-    if (this.Ot && this.Dt) {
+    if (!(t & this.gt)) return super.notify(e, t, n, i);
+    if (this._t && this.yt) {
       const e = untrack(() => {
         try {
-          return this.Dt();
+          return this.yt();
         } catch {
           return ON_INIT;
         }
       });
-      if (e !== this.yt) {
-        this.yt = e;
-        this.Ot = false;
-        this.ct.clear();
+      if (e !== this.vt) {
+        this.vt = e;
+        this._t = false;
+        this.ft.clear();
       }
     }
-    if (this.Pt & STATUS_PENDING && this.Ot) return super.notify(e, t, n, i);
-    if (this.Pt & STATUS_PENDING && n & STATUS_ERROR) {
+    if (this.gt & STATUS_PENDING && this._t) return super.notify(e, t, n, i);
+    if (this.gt & STATUS_PENDING && n & STATUS_ERROR) {
       return super.notify(e, STATUS_ERROR, n, i);
     }
-    if (n & this.Pt) {
-      this.ft = true;
+    if (n & this.gt) {
+      this.Et = true;
       const t = i?.source || e.Re?.source;
       if (t) {
-        const e = this.ct.size === 0;
-        this.ct.add(t);
-        if (e) setSignal(this.Et, true);
+        const e = this.ft.size === 0;
+        this.ft.add(t);
+        if (e) setSignal(this.St, true);
       }
     }
-    t &= ~this.Pt;
+    t &= ~this.gt;
     return t ? super.notify(e, t, n, i) : true;
   }
   checkSources() {
-    for (const e of this.ct) {
+    for (const e of this.ft) {
       if (
         e._ & REACTIVE_DISPOSED ||
-        (!(e.he & this.Pt) && !(this.Pt & STATUS_ERROR && e.he & STATUS_PENDING))
+        (!(e.he & this.gt) && !(this.gt & STATUS_ERROR && e.he & STATUS_PENDING))
       )
-        this.ct.delete(e);
+        this.ft.delete(e);
     }
-    if (!this.ct.size) {
-      if (this.Pt & STATUS_PENDING && this.ft && !this.Ot && this.gt) {
-        this.ft = !!(this.gt.he & this.Pt);
+    if (!this.ft.size) {
+      if (this.gt & STATUS_PENDING && this.Et && !this._t && this.Dt) {
+        this.Et = !!(this.Dt.he & this.gt);
       } else {
-        this.ft = false;
+        this.Et = false;
       }
-      if (!this.ft) {
-        setSignal(this.Et, false);
-        if (this.Dt) {
+      if (!this.Et) {
+        setSignal(this.St, false);
+        if (this.yt) {
           try {
-            this.yt = untrack(() => this.Dt());
+            this.vt = untrack(() => this.yt());
           } catch {}
         }
       }
     }
-    if (_revealUsed) this.dt?.evaluate();
+    if (_revealUsed) this.Ot?.evaluate();
   }
 }
 function createCollectionBoundary(e, t, n, i) {
   const r = createOwner();
   if (_revealUsed) setContext(RevealControllerContext, null, r);
   const s = new CollectionQueue(e);
-  if (i) s.Dt = i;
-  const o = (s.gt = createBoundChildren(r, t, s, e));
+  if (i) s.yt = i;
+  const o = (s.Dt = createBoundChildren(r, t, s, e));
   untrack(() => {
     let t = false;
     try {
@@ -3815,21 +3821,21 @@ function createCollectionBoundary(e, t, n, i) {
       if (e instanceof NotReadyError) t = true;
       else throw e;
     }
-    s.ft = t || !!(o.he & e) || o.Re instanceof NotReadyError;
+    s.Et = t || !!(o.he & e) || o.Re instanceof NotReadyError;
   });
   const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
   if (u) {
-    s.dt = u;
+    s.Ot = u;
     u.register(s);
     cleanup(() => u.unregister(s));
   }
   return accessor(
     computed(() => {
-      if (!read(s.Et)) {
+      if (!read(s.St)) {
         const e = read(o);
-        if (!untrack(() => read(s.Et))) return ((s.Ot = true), e);
+        if (!untrack(() => read(s.St))) return ((s._t = true), e);
       }
-      if (_revealUsed && read(s.St)) return undefined;
+      if (_revealUsed && read(s.Tt)) return undefined;
       return n(s);
     })
   );
@@ -3839,10 +3845,10 @@ function createLoadingBoundary(e, t, n) {
 }
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.ct.values().next().value;
+    let n = e.ft.values().next().value;
     const i = n.Re?.cause ?? n.Re;
     return t(i, () => {
-      for (const t of e.ct) recompute(t);
+      for (const t of e.ft) recompute(t);
       schedule();
     });
   });
@@ -3863,7 +3869,7 @@ function createRevealOrder(e, t) {
       o.evaluate();
     });
     if (i) {
-      o.Tt = i;
+      o.dt = i;
       i.register(o);
       cleanup(() => i.unregister(o));
     }

package/dist/types/map.d.ts

@@ -2,8 +2,14 @@ import { type Accessor } from "./signals.js";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
  * Reactively maps an array, reusing the previously-mapped value for unchanged
- * items. The callback receives `(value, index)` as accessors so individual
- * items and indexes can be subscribed to without re-running the mapper.
+ * items.
+ *
+ * The callback shape follows the keying mode:
+ * - default / `keyed: true` receives `(item, index)` where `item` is the raw
+ *   row value and `index` is an accessor.
+ * - `keyed: false` receives `(item, index)` where `item` is an accessor and
+ *   `index` is a stable number.
+ * - `keyed: item => key` receives accessors for both arguments.
  *
  * This is the underlying helper that powers `<For>`. App code should use
  * `<For>` directly; reach for `mapArray` when implementing custom list
@@ -19,15 +25,25 @@ export type Maybe<T> = T | void | null | undefined | false;
  * ```ts
  * const view = mapArray(
  *   items,
- *   (item, index) => `${index()}: ${item().label}`,
+ *   (item, index) => `${index()}: ${item.label}`,
  *   { fallback: () => "no items" }
  * );
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: boolean | ((item: Item) => any);
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: true;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options: {
+    keyed: false;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options: {
+    keyed: (item: Item) => any;
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;

package/dist/types-cjs/map.d.cts

@@ -2,8 +2,14 @@ import { type Accessor } from "./signals.cjs";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
  * Reactively maps an array, reusing the previously-mapped value for unchanged
- * items. The callback receives `(value, index)` as accessors so individual
- * items and indexes can be subscribed to without re-running the mapper.
+ * items.
+ *
+ * The callback shape follows the keying mode:
+ * - default / `keyed: true` receives `(item, index)` where `item` is the raw
+ *   row value and `index` is an accessor.
+ * - `keyed: false` receives `(item, index)` where `item` is an accessor and
+ *   `index` is a stable number.
+ * - `keyed: item => key` receives accessors for both arguments.
  *
  * This is the underlying helper that powers `<For>`. App code should use
  * `<For>` directly; reach for `mapArray` when implementing custom list
@@ -19,15 +25,25 @@ export type Maybe<T> = T | void | null | undefined | false;
  * ```ts
  * const view = mapArray(
  *   items,
- *   (item, index) => `${index()}: ${item().label}`,
+ *   (item, index) => `${index()}: ${item.label}`,
  *   { fallback: () => "no items" }
  * );
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: boolean | ((item: Item) => any);
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: true;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options: {
+    keyed: false;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options: {
+    keyed: (item: Item) => any;
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.11",
+  "version": "2.0.0-beta.12",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",