@solidjs/signals 0.3.1 → 0.3.2

package/dist/prod.js

@@ -43,66 +43,62 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.K)
+  if (!globalQueue.J)
     queueMicrotask(flushSync);
 }
+var pureQueue = [];
 var Queue = class {
-  n = null;
-  K = false;
-  s = [[], [], []];
-  F = [];
+  o = null;
+  J = false;
+  K = [[], []];
+  E = [];
   created = clock;
   enqueue(type, node) {
-    this.s[0].push(node);
+    pureQueue.push(node);
     if (type)
-      this.s[type].push(node);
+      this.K[type - 1].push(node);
     schedule();
   }
   run(type) {
-    if (this.s[type].length) {
-      if (type === EFFECT_PURE) {
-        runPureQueue(this.s[type]);
-        this.s[type] = [];
-      } else {
-        const effects = this.s[type];
-        this.s[type] = [];
-        runEffectQueue(effects);
-      }
+    if (type === EFFECT_PURE) {
+      pureQueue.length && runPureQueue(pureQueue);
+      pureQueue = [];
+      return;
+    } else if (this.K[type - 1].length) {
+      const effects = this.K[type - 1];
+      this.K[type - 1] = [];
+      runEffectQueue(effects);
     }
-    let rerun = false;
-    for (let i = 0; i < this.F.length; i++) {
-      rerun = this.F[i].run(type) || rerun;
+    for (let i = 0; i < this.E.length; i++) {
+      this.E[i].run(type);
     }
-    if (type === EFFECT_PURE)
-      return rerun || !!this.s[type].length;
   }
   flush() {
-    if (this.K)
+    if (this.J)
       return;
-    this.K = true;
+    this.J = true;
     try {
-      while (this.run(EFFECT_PURE)) {
-      }
+      this.run(EFFECT_PURE);
       incrementClock();
       scheduled = false;
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.K = false;
+      this.J = false;
     }
   }
   addChild(child) {
-    this.F.push(child);
-    child.n = this;
+    this.E.push(child);
+    child.o = this;
   }
   removeChild(child) {
-    const index = this.F.indexOf(child);
+    const index = this.E.indexOf(child);
     if (index >= 0)
-      this.F.splice(index, 1);
+      this.E.splice(index, 1);
   }
   notify(...args) {
-    if (this.n)
-      return this.n.notify(...args);
+    if (this.o)
+      return this.o.notify(...args);
     return false;
   }
 };
@@ -114,7 +110,7 @@ function flushSync() {
 }
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.n) {
+  for (let current = node; current !== null; current = current.o) {
     if (current.a !== STATE_CLEAN) {
       ancestors.push(current);
     }
@@ -179,32 +175,32 @@ var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
-  n = null;
+  o = null;
   m = null;
-  t = null;
+  s = null;
   a = STATE_CLEAN;
   l = null;
-  o = defaultContext;
+  p = defaultContext;
   h = globalQueue;
   W = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
     this.id = id;
     if (currentOwner) {
-      if (!id && currentOwner.id)
+      if (id == null && currentOwner.id != null)
         this.id = currentOwner.getNextChildId();
       !skipAppend && currentOwner.append(this);
     }
   }
   append(child) {
-    child.n = this;
-    child.t = this;
+    child.o = this;
+    child.s = this;
     if (this.m)
-      this.m.t = child;
+      this.m.s = child;
     child.m = this.m;
     this.m = child;
-    if (child.o !== this.o) {
-      child.o = { ...this.o, ...child.o };
+    if (child.p !== this.p) {
+      child.p = { ...this.p, ...child.p };
     }
     if (this.h)
       child.h = this.h;
@@ -212,8 +208,8 @@ var Owner = class {
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.t || this.n : this, current = this.m, next = null;
-    while (current && current.n === this) {
+    let head = self ? this.s || this.o : this, current = this.m, next = null;
+    while (current && current.o === this) {
       current.dispose(true);
       current.y();
       next = current.m;
@@ -224,16 +220,16 @@ var Owner = class {
     if (self)
       this.y();
     if (current)
-      current.t = !self ? this : this.t;
+      current.s = !self ? this : this.s;
     if (head)
       head.m = current;
   }
   y() {
-    if (this.t)
-      this.t.m = null;
-    this.n = null;
-    this.t = null;
-    this.o = defaultContext;
+    if (this.s)
+      this.s.m = null;
+    this.o = null;
+    this.s = null;
+    this.p = defaultContext;
     this.a = STATE_DISPOSED;
     this.emptyDisposal();
   }
@@ -251,7 +247,7 @@ var Owner = class {
     this.l = null;
   }
   getNextChildId() {
-    if (this.id)
+    if (this.id != null)
       return formatId(this.id, this.W++);
     throw new Error("Cannot get child id from owner without an id");
   }
@@ -263,7 +259,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.o[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.p[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -273,13 +269,13 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.o = {
-    ...owner.o,
+  owner.p = {
+    ...owner.p,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.o[context.id]);
+  return !isUndefined(owner?.p[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
@@ -321,7 +317,7 @@ var Computation = class extends Owner {
   c = null;
   e = null;
   g;
-  G;
+  F;
   z;
   // Used in __DEV__ mode, hopefully removed in production
   ba;
@@ -334,7 +330,7 @@ var Computation = class extends Owner {
   /** Which flags raised by sources are handled, vs. being passed through. */
   T = DEFAULT_FLAGS;
   A = -1;
-  B = false;
+  w = false;
   constructor(initialValue, compute2, options) {
     super(null, compute2 === null);
     this.z = compute2;
@@ -356,7 +352,7 @@ var Computation = class extends Owner {
     track(this);
     newFlags |= this.f & ~currentMask;
     if (this.f & ERROR_BIT) {
-      throw this.G;
+      throw this.F;
     } else {
       return this.g;
     }
@@ -396,7 +392,7 @@ var Computation = class extends Owner {
     const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || this.f & LOADING_BIT & ~flags || this.S === false || !this.S(this.g, newValue));
     if (valueChanged) {
       this.g = newValue;
-      this.G = void 0;
+      this.F = void 0;
     }
     const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
     this.f = flags;
@@ -416,9 +412,9 @@ var Computation = class extends Owner {
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   r(state, skipQueue) {
-    if (this.a >= state && !this.B)
+    if (this.a >= state && !this.w)
       return;
-    this.B = !!skipQueue;
+    this.w = !!skipQueue;
     this.a = state;
     if (this.e) {
       for (let i = 0; i < this.e.length; i++) {
@@ -455,7 +451,7 @@ var Computation = class extends Owner {
     }
   }
   L(error) {
-    this.G = error;
+    this.F = error;
     this.write(UNCHANGED, this.f & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
@@ -756,27 +752,27 @@ function flattenArray(children, results = [], options) {
 var Effect = class extends Computation {
   M;
   N;
-  C;
+  B;
   U = false;
   O;
-  u;
+  t;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this.M = effect;
     this.N = error;
     this.O = initialValue;
-    this.u = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.u === EFFECT_RENDER) {
+    this.t = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.t === EFFECT_RENDER) {
       this.z = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
     this.x();
-    !options?.defer && (this.u === EFFECT_USER ? this.h.enqueue(this.u, this) : this.V());
+    !options?.defer && (this.t === EFFECT_USER ? this.h.enqueue(this.t, this) : this.V());
   }
   write(value, flags = 0) {
     if (this.a == STATE_DIRTY) {
       this.f;
       this.f = flags;
-      if (this.u === EFFECT_RENDER) {
+      if (this.t === EFFECT_RENDER) {
         this.h.notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
@@ -790,17 +786,17 @@ var Effect = class extends Computation {
     if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.u, this);
+      this.h.enqueue(this.t, this);
     this.a = state;
   }
   L(error) {
-    this.G = error;
-    this.C?.();
+    this.F = error;
+    this.B?.();
     this.h.notify(this, LOADING_BIT, 0);
     this.f = ERROR_BIT;
-    if (this.u === EFFECT_USER) {
+    if (this.t === EFFECT_USER) {
       try {
-        return this.N ? this.C = this.N(error) : console.error(new EffectError(this.M, error));
+        return this.N ? this.B = this.N(error) : console.error(new EffectError(this.M, error));
       } catch (e) {
         error = e;
       }
@@ -814,15 +810,15 @@ var Effect = class extends Computation {
     this.M = void 0;
     this.O = void 0;
     this.N = void 0;
-    this.C?.();
-    this.C = void 0;
+    this.B?.();
+    this.B = void 0;
     super.y();
   }
   V() {
     if (this.U && this.a !== STATE_DISPOSED) {
-      this.C?.();
+      this.B?.();
       try {
-        this.C = this.M(this.g, this.O);
+        this.B = this.M(this.g, this.O);
       } catch (e) {
         if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
           throw e;
@@ -839,9 +835,9 @@ var EagerComputation = class extends Computation {
     !options?.defer && this.x();
   }
   r(state, skipQueue) {
-    if (this.a >= state && !this.B)
+    if (this.a >= state && !this.w)
       return;
-    if (this.a === STATE_CLEAN && !skipQueue)
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.w))
       this.h.enqueue(EFFECT_PURE, this);
     super.r(state, skipQueue);
   }
@@ -851,28 +847,28 @@ var ProjectionComputation = class extends Computation {
     super(void 0, compute2);
   }
   r(state, skipQueue) {
-    if (this.a >= state && !this.B)
+    if (this.a >= state && !this.w)
       return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.B))
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.w))
       this.h.enqueue(EFFECT_PURE, this);
     super.r(state, true);
-    this.B = !!skipQueue;
+    this.w = !!skipQueue;
   }
 };
 
 // src/core/boundaries.ts
 var BoundaryComputation = class extends EagerComputation {
-  H;
+  G;
   constructor(compute2, propagationMask) {
     super(void 0, compute2, { defer: true });
-    this.H = propagationMask;
+    this.G = propagationMask;
   }
   write(value, flags) {
-    super.write(value, flags & ~this.H);
-    if (this.H & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
+    super.write(value, flags & ~this.G);
+    if (this.G & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
       flags &= ~LOADING_BIT;
     }
-    this.h.notify(this, this.H, flags);
+    this.h.notify(this, this.G, flags);
     return this.g;
   }
 };
@@ -890,20 +886,20 @@ function createBoundChildren(owner, fn, queue, mask) {
   );
 }
 var ConditionalQueue = class extends Queue {
-  p;
+  n;
   P = /* @__PURE__ */ new Set();
   Q = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.p = disabled;
+    this.n = disabled;
   }
   run(type) {
-    if (type && this.p.read())
+    if (!type || this.n.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (this.p.read()) {
+    if (this.n.read()) {
       if (type === LOADING_BIT) {
         flags & LOADING_BIT ? this.Q.add(node) : this.Q.delete(node);
       }
@@ -918,22 +914,27 @@ var ConditionalQueue = class extends Queue {
 var CollectionQueue = class extends Queue {
   R;
   b = /* @__PURE__ */ new Set();
-  p = new Computation(false, null);
+  n = new Computation(false, null);
   constructor(type) {
     super();
     this.R = type;
   }
+  run(type) {
+    if (!type || this.n.read())
+      return;
+    return super.run(type);
+  }
   notify(node, type, flags) {
     if (!(type & this.R))
       return super.notify(node, type, flags);
     if (flags & this.R) {
       this.b.add(node);
       if (this.b.size === 1)
-        this.p.write(true);
+        this.n.write(true);
     } else {
       this.b.delete(node);
       if (this.b.size === 0)
-        this.p.write(false);
+        this.n.write(false);
     }
     type &= ~this.R;
     return type ? super.notify(node, type, flags) : true;
@@ -944,8 +945,8 @@ function createBoundary(fn, condition) {
   const queue = new ConditionalQueue(new Computation(void 0, () => condition() === "hidden" /* HIDDEN */));
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
-    const disabled = queue.p.read();
-    tree.H = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    const disabled = queue.n.read();
+    tree.G = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
       queue.Q.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
       queue.P.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
@@ -953,16 +954,16 @@ function createBoundary(fn, condition) {
       queue.P.clear();
     }
   });
-  return () => queue.p.read() ? void 0 : tree.read();
+  return () => queue.n.read() ? void 0 : tree.read();
 }
 function createCollectionBoundary(type, fn, fallback) {
   const owner = new Owner();
   const queue = new CollectionQueue(type);
   const tree = createBoundChildren(owner, fn, queue, type);
   const decision = new Computation(void 0, () => {
-    if (!queue.p.read()) {
+    if (!queue.n.read()) {
       const resolved = tree.read();
-      if (!queue.p.read())
+      if (!queue.n.read())
         return resolved;
     }
     return fallback(queue);
@@ -976,11 +977,11 @@ function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(
     ERROR_BIT,
     fn,
-    (queue) => fallback(queue.b.values().next().value.G, () => {
+    (queue) => fallback(queue.b.values().next().value.F, () => {
       incrementClock();
       for (let node of queue.b) {
         node.a = STATE_DIRTY;
-        node.h?.enqueue(node.u, node);
+        node.h?.enqueue(node.t, node);
       }
     })
   );
@@ -1016,7 +1017,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node.c?.length && node.m?.n !== node) {
+      if (!node.c?.length && node.m?.o !== node) {
         node.dispose();
         node = void 0;
       }
@@ -1651,52 +1652,52 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    I: new Owner(),
+    H: new Owner(),
     i: 0,
     _: list,
-    w: [],
-    D: map,
+    u: [],
+    C: map,
     d: [],
     b: [],
-    E: keyFn,
+    D: keyFn,
     j: keyFn || options?.keyed === false ? [] : void 0,
     k: map.length > 1 ? [] : void 0,
-    J: options?.fallback
+    I: options?.fallback
   });
 }
 function updateKeyedMap() {
   const newItems = this._() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.I, () => {
+  runWithOwner(this.H, () => {
     let i, j, mapper = this.j ? () => {
       this.j[j] = new Computation(newItems[j], null);
       this.k && (this.k[j] = new Computation(j, null));
-      return this.D(
+      return this.C(
         Computation.prototype.read.bind(this.j[j]),
         this.k ? Computation.prototype.read.bind(this.k[j]) : void 0
       );
     } : this.k ? () => {
       const item = newItems[j];
       this.k[j] = new Computation(j, null);
-      return this.D(() => item, Computation.prototype.read.bind(this.k[j]));
+      return this.C(() => item, Computation.prototype.read.bind(this.k[j]));
     } : () => {
       const item = newItems[j];
-      return this.D(() => item);
+      return this.C(() => item);
     };
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.I.dispose(false);
+        this.H.dispose(false);
         this.b = [];
-        this.w = [];
+        this.u = [];
         this.d = [];
         this.i = 0;
         this.j && (this.j = []);
         this.k && (this.k = []);
       }
-      if (this.J && !this.d[0]) {
+      if (this.I && !this.d[0]) {
         this.d[0] = compute(
           this.b[0] = new Owner(),
-          this.J,
+          this.I,
           null
         );
       }
@@ -1705,17 +1706,17 @@ function updateKeyedMap() {
         this.b[0].dispose();
       this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.w[j] = newItems[j];
+        this.u[j] = newItems[j];
         this.d[j] = compute(this.b[j] = new Owner(), mapper, null);
       }
       this.i = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.j ? new Array(newLen) : void 0, tempIndexes = this.k ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.w[start] === newItems[start] || this.j && compare(this.E, this.w[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.u[start] === newItems[start] || this.j && compare(this.D, this.u[start], newItems[start])); start++) {
         if (this.j)
           this.j[start].write(newItems[start]);
       }
-      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.w[end] === newItems[newEnd] || this.j && compare(this.E, this.w[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.u[end] === newItems[newEnd] || this.j && compare(this.D, this.u[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.d[end];
         tempNodes[newEnd] = this.b[end];
         tempRows && (tempRows[newEnd] = this.j[end]);
@@ -1725,14 +1726,14 @@ function updateKeyedMap() {
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.E ? this.E(item) : item;
+        key = this.D ? this.D(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.w[i];
-        key = this.E ? this.E(item) : item;
+        item = this.u[i];
+        key = this.D ? this.D(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.d[i];
@@ -1761,39 +1762,39 @@ function updateKeyedMap() {
         }
       }
       this.d = this.d.slice(0, this.i = newLen);
-      this.w = newItems.slice(0);
+      this.u = newItems.slice(0);
     }
   });
   return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    I: new Owner(),
+    H: new Owner(),
     i: 0,
     q: 0,
     $: count,
-    D: map,
+    C: map,
     b: [],
     d: [],
     aa: options?.from,
-    J: options?.fallback
+    I: options?.fallback
   });
 }
 function updateRepeat() {
   const newLen = this.$();
   const from = this.aa?.() || 0;
-  runWithOwner(this.I, () => {
+  runWithOwner(this.H, () => {
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.I.dispose(false);
+        this.H.dispose(false);
         this.b = [];
         this.d = [];
         this.i = 0;
       }
-      if (this.J && !this.d[0]) {
+      if (this.I && !this.d[0]) {
         this.d[0] = compute(
           this.b[0] = new Owner(),
-          this.J,
+          this.I,
           null
         );
       }
@@ -1823,7 +1824,7 @@ function updateRepeat() {
       for (let i2 = 0; i2 < difference; i2++) {
         this.d[i2] = compute(
           this.b[i2] = new Owner(),
-          () => this.D(i2 + from),
+          () => this.C(i2 + from),
           null
         );
       }
@@ -1831,7 +1832,7 @@ function updateRepeat() {
     for (let i = prevTo; i < to; i++) {
       this.d[i - from] = compute(
         this.b[i - from] = new Owner(),
-        () => this.D(i),
+        () => this.C(i),
         null
       );
     }

package/dist/types/core/boundaries.d.ts

@@ -6,6 +6,7 @@ export declare class CollectionQueue extends Queue {
     _nodes: Set<Effect>;
     _disabled: Computation<boolean>;
     constructor(type: number);
+    run(type: number): void;
     notify(node: Effect, type: number, flags: number): boolean;
 }
 export declare enum BoundaryMode {

package/dist/types/core/scheduler.d.ts

@@ -15,11 +15,11 @@ export interface IQueue {
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
     _running: boolean;
-    _queues: [Computation[], Effect[], Effect[]];
+    _queues: [Effect[], Effect[]];
     _children: IQueue[];
     created: number;
     enqueue<T extends Computation | Effect>(type: number, node: T): void;
-    run(type: number): boolean | undefined;
+    run(type: number): void;
     flush(): void;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;