@solidjs/signals 0.2.2 → 0.2.4

package/dist/dev.js

@@ -138,60 +138,6 @@ function runEffectQueue(queue) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function flatten(children, options) {
-  if (typeof children === "function" && !children.length) {
-    if (options?.doNotUnwrap)
-      return children;
-    do {
-      children = children();
-    } while (typeof children === "function" && !children.length);
-  }
-  if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
-    return;
-  if (Array.isArray(children)) {
-    let results = [];
-    if (flattenArray(children, results, options)) {
-      return () => {
-        let nested = [];
-        flattenArray(results, nested, { ...options, doNotUnwrap: false });
-        return nested;
-      };
-    }
-    return results;
-  }
-  return children;
-}
-function flattenArray(children, results = [], options) {
-  let notReady = null;
-  let needsUnwrap = false;
-  for (let i = 0; i < children.length; i++) {
-    try {
-      let child = children[i];
-      if (typeof child === "function" && !child.length) {
-        if (options?.doNotUnwrap) {
-          results.push(child);
-          needsUnwrap = true;
-          continue;
-        }
-        do {
-          child = child();
-        } while (typeof child === "function" && !child.length);
-      }
-      if (Array.isArray(child)) {
-        needsUnwrap = flattenArray(child, results, options);
-      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
-      } else
-        results.push(child);
-    } catch (e) {
-      if (!(e instanceof NotReadyError))
-        throw e;
-      notReady = e;
-    }
-  }
-  if (notReady)
-    throw notReady;
-  return needsUnwrap;
-}
 
 // src/core/owner.ts
 var currentOwner = null;
@@ -754,6 +700,68 @@ function compute(owner, fn, observer) {
     notStale = prevNotStale;
   }
 }
+function flatten(children, options) {
+  try {
+    if (typeof children === "function" && !children.length) {
+      if (options?.doNotUnwrap)
+        return children;
+      do {
+        children = children();
+      } while (typeof children === "function" && !children.length);
+    }
+    if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
+      return;
+    if (Array.isArray(children)) {
+      let results = [];
+      if (flattenArray(children, results, options)) {
+        return () => {
+          let nested = [];
+          flattenArray(results, nested, { ...options, doNotUnwrap: false });
+          return nested;
+        };
+      }
+      return results;
+    }
+    return children;
+  } catch (e) {
+    if (options?.skipNonRendered && e instanceof NotReadyError) {
+      newFlags |= LOADING_BIT;
+      return void 0;
+    }
+    throw e;
+  }
+}
+function flattenArray(children, results = [], options) {
+  let notReady = null;
+  let needsUnwrap = false;
+  for (let i = 0; i < children.length; i++) {
+    try {
+      let child = children[i];
+      if (typeof child === "function" && !child.length) {
+        if (options?.doNotUnwrap) {
+          results.push(child);
+          needsUnwrap = true;
+          continue;
+        }
+        do {
+          child = child();
+        } while (typeof child === "function" && !child.length);
+      }
+      if (Array.isArray(child)) {
+        needsUnwrap = flattenArray(child, results, options);
+      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
+      } else
+        results.push(child);
+    } catch (e) {
+      if (!(e instanceof NotReadyError))
+        throw e;
+      notReady = e;
+    }
+  }
+  if (notReady)
+    throw notReady;
+  return needsUnwrap;
+}
 function createBoundary(fn, queue) {
   const owner = new Owner();
   const parentQueue = owner._queue;
@@ -777,7 +785,7 @@ var Effect = class extends Computation {
     this._prevValue = initialValue;
     this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this._type === EFFECT_RENDER) {
-      this._compute = (p) => getClock() > this._queue.created ? latest(() => compute2(p)) : compute2(p);
+      this._compute = (p) => getClock() > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
     this._updateIfNecessary();
     !options?.defer && (this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect());
@@ -808,9 +816,9 @@ var Effect = class extends Computation {
   _setError(error) {
     this._cleanup?.();
     if (this._stateFlags & LOADING_BIT) {
-      this._stateFlags = 0;
       this._queue._update?.(this);
     }
+    this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
         return this._onerror ? this._cleanup = this._onerror(error) : console.error(new EffectError(this._effect, error));
@@ -1109,12 +1117,15 @@ function resolve(fn) {
 
 // src/store/projection.ts
 function createProjection(fn, initialValue = {}) {
-  const [store, setStore] = createStore(initialValue);
+  const [store] = createStore(fn, initialValue);
+  return store;
+}
+function wrapProjection(fn, store, setStore) {
   const node = new ProjectionComputation(() => {
     setStore(fn);
   });
   const wrapped = /* @__PURE__ */ new WeakMap();
-  return wrap(store, node, wrapped);
+  return [wrap(store, node, wrapped), setStore];
 }
 function wrap(source, node, wrapped) {
   if (wrapped.has(source))
@@ -1312,10 +1323,8 @@ function setProperty(state, property, value, deleting = false) {
 }
 function createStore(first, second) {
   const derived = typeof first === "function", store = derived ? second : first;
-  if (derived)
-    return createProjection(first, store);
   const unwrappedStore = unwrap(store, false);
-  const wrappedStore = wrap2(unwrappedStore);
+  let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
       Writing.add(unwrappedStore);
@@ -1324,6 +1333,8 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
+  if (derived)
+    return wrapProjection(first, wrappedStore, setStore);
   return [wrappedStore, setStore];
 }
 
@@ -1439,7 +1450,7 @@ function reconcile(value, key) {
   };
 }
 
-// src/store/utilities.ts
+// src/store/utils.ts
 function trueFn() {
   return true;
 }
@@ -1710,15 +1721,18 @@ function repeat(count, map, options) {
   return updateRepeat.bind({
     _owner: new Owner(),
     _len: 0,
+    _offset: 0,
     _count: count,
     _map: map,
     _nodes: [],
     _mappings: [],
+    _from: options?.from,
     _fallback: options?.fallback
   });
 }
 function updateRepeat() {
   const newLen = this._count();
+  const from = this._from?.() || 0;
   runWithOwner(this._owner, () => {
     if (newLen === 0) {
       if (this._len !== 0) {
@@ -1734,21 +1748,47 @@ function updateRepeat() {
           null
         );
       }
-    } else {
-      if (this._len === 0 && this._nodes[0])
-        this._nodes[0].dispose();
-      for (let i = this._len; i < newLen; i++) {
-        this._mappings[i] = compute(
-          this._nodes[i] = new Owner(),
-          () => this._map(i),
+      return;
+    }
+    const to = from + newLen;
+    const prevTo = this._offset + this._len;
+    if (this._len === 0 && this._nodes[0])
+      this._nodes[0].dispose();
+    for (let i = to; i < prevTo; i++)
+      this._nodes[i - this._offset].dispose();
+    if (this._offset < from) {
+      let i = this._offset;
+      while (i < from && i < this._len)
+        this._nodes[i++].dispose();
+      this._nodes.splice(0, from - this._offset);
+      this._mappings.splice(0, from - this._offset);
+    } else if (this._offset > from) {
+      let i = prevTo - this._offset - 1;
+      let difference = this._offset - from;
+      this._nodes.length = this._mappings.length = newLen;
+      while (i >= difference) {
+        this._nodes[i] = this._nodes[i - difference];
+        this._mappings[i] = this._mappings[i - difference];
+        i--;
+      }
+      for (let i2 = 0; i2 < difference; i2++) {
+        this._mappings[i2] = compute(
+          this._nodes[i2] = new Owner(),
+          () => this._map(i2 + from),
           null
         );
       }
-      for (let i = newLen; i < this._len; i++)
-        this._nodes[i].dispose();
-      this._mappings = this._mappings.slice(0, newLen);
-      this._len = newLen;
     }
+    for (let i = prevTo; i < to; i++) {
+      this._mappings[i - from] = compute(
+        this._nodes[i - from] = new Owner(),
+        () => this._map(i),
+        null
+      );
+    }
+    this._mappings = this._mappings.slice(0, newLen);
+    this._offset = from;
+    this._len = newLen;
   });
   return this._mappings;
 }