@solidjs/signals 0.2.3 → 0.2.4

package/dist/dev.js

@@ -1117,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))
@@ -1320,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);
@@ -1332,6 +1333,8 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
+  if (derived)
+    return wrapProjection(first, wrappedStore, setStore);
   return [wrappedStore, setStore];
 }
 
@@ -1718,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) {
@@ -1742,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;
 }