@solidjs/signals 0.2.3 → 0.2.5

package/dist/dev.js

@@ -986,7 +986,7 @@ function createAsync(compute2, value, options) {
           _value: source
         };
       }
-      const signal = new Computation(value2, null, options);
+      const signal = new Computation(value2, null, iterator ? { ...options, equals: false } : options);
       const w = signal.wait;
       signal.wait = function() {
         if (signal._stateFlags & ERROR_BIT && signal._time <= getClock()) {
@@ -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))
@@ -1147,8 +1150,10 @@ function wrap(source, node, wrapped) {
 // src/store/store.ts
 var $RAW = Symbol("STORE_RAW" );
 var $TRACK = Symbol("STORE_TRACK" );
+var $DEEP = Symbol("STORE_DEEP" );
 var $TARGET = Symbol("STORE_TARGET" );
 var $PROXY = Symbol("STORE_PROXY" );
+var PARENTS = /* @__PURE__ */ new WeakMap();
 var STORE_VALUE = "v";
 var STORE_NODE = "n";
 var STORE_HAS = "h";
@@ -1171,11 +1176,11 @@ function wrap2(value) {
 function isWrappable(obj) {
   return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
-function unwrap(item, deep = true, set) {
+function unwrap(item, deep2 = true, set) {
   let result, unwrapped, v, prop;
   if (result = item != null && item[$RAW])
     return result;
-  if (!deep)
+  if (!deep2)
     return item;
   if (!isWrappable(item) || set?.has(item))
     return item;
@@ -1185,11 +1190,11 @@ function unwrap(item, deep = true, set) {
   if (Array.isArray(item)) {
     for (let i = 0, l = item.length; i < l; i++) {
       v = item[i];
-      if ((unwrapped = unwrap(v, deep, set)) !== v)
+      if ((unwrapped = unwrap(v, deep2, set)) !== v)
         item[i] = unwrapped;
     }
   } else {
-    if (!deep)
+    if (!deep2)
       return item;
     const keys = Object.keys(item);
     for (let i = 0, l = keys.length; i < l; i++) {
@@ -1198,7 +1203,7 @@ function unwrap(item, deep = true, set) {
       if (desc.get)
         continue;
       v = item[prop];
-      if ((unwrapped = unwrap(v, deep, set)) !== v)
+      if ((unwrapped = unwrap(v, deep2, set)) !== v)
         item[prop] = unwrapped;
     }
   }
@@ -1231,8 +1236,8 @@ function proxyDescriptor(target, property) {
   desc.get = () => target[STORE_VALUE][$PROXY][property];
   return desc;
 }
-function trackSelf(target) {
-  getObserver() && getNode(getNodes(target, STORE_NODE), $TRACK, void 0, false).read();
+function trackSelf(target, symbol = $TRACK) {
+  getObserver() && getNode(getNodes(target, STORE_NODE), symbol, void 0, false).read();
 }
 function ownKeys(target) {
   trackSelf(target);
@@ -1247,8 +1252,8 @@ var proxyTraps = {
       return target[STORE_VALUE];
     if (property === $PROXY)
       return receiver;
-    if (property === $TRACK) {
-      trackSelf(target);
+    if (property === $TRACK || property === $DEEP) {
+      trackSelf(target, property);
       return receiver;
     }
     const nodes = getNodes(target, STORE_NODE);
@@ -1269,7 +1274,7 @@ var proxyTraps = {
         let proto;
         return !Array.isArray(storeValue) && (proto = Object.getPrototypeOf(storeValue)) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        value = getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
+        return getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
       }
     }
     return isWrappable(value) ? wrap2(value) : value;
@@ -1304,6 +1309,13 @@ function setProperty(state, property, value, deleting = false) {
     delete state[property];
   else
     state[property] = value;
+  const wrappable = isWrappable(value);
+  if (isWrappable(prev)) {
+    const parents = PARENTS.get(prev);
+    parents && (parents instanceof Set ? parents.delete(state) : PARENTS.delete(prev));
+  }
+  if (recursivelyNotify(state) && wrappable)
+    recursivelyAddParent(value[$RAW] || value, state);
   const target = state[$PROXY]?.[$TARGET];
   if (!target)
     return;
@@ -1312,18 +1324,55 @@ function setProperty(state, property, value, deleting = false) {
   else
     target[STORE_HAS]?.[property]?.write(true);
   const nodes = getNodes(target, STORE_NODE);
-  let node;
-  if (node = nodes[property])
-    node.write(isWrappable(value) ? wrap2(value) : value);
-  Array.isArray(state) && state.length !== len && (node = nodes.length) && node.write(state.length);
-  (node = nodes[$TRACK]) && node.write(void 0);
+  nodes[property]?.write(wrappable ? wrap2(value) : value);
+  Array.isArray(state) && state.length !== len && nodes.length?.write(state.length);
+  nodes[$TRACK]?.write(void 0);
+}
+function recursivelyNotify(state) {
+  let target = state[$PROXY]?.[$TARGET];
+  let notified = false;
+  target && (getNodes(target, STORE_NODE)[$DEEP]?.write(void 0), notified = true);
+  const parents = PARENTS.get(state);
+  if (!parents)
+    return notified;
+  if (parents instanceof Set) {
+    for (let parent of parents)
+      notified = recursivelyNotify(parent) || notified;
+  } else
+    notified = recursivelyNotify(parents) || notified;
+  return notified;
+}
+function recursivelyAddParent(state, parent) {
+  if (parent) {
+    let parents = PARENTS.get(state);
+    if (!parents)
+      PARENTS.set(state, parent);
+    else if (parents !== parent) {
+      if (!(parents instanceof Set))
+        PARENTS.set(state, parents = /* @__PURE__ */ new Set([parents]));
+      else if (parents.has(parent))
+        return;
+      parents.add(parent);
+    } else
+      return;
+  }
+  if (Array.isArray(state)) {
+    for (let i = 0; i < state.length; i++) {
+      const item = state[i];
+      isWrappable(item) && recursivelyAddParent(item[$RAW] || item, state);
+    }
+  } else {
+    const keys = Object.keys(state);
+    for (let i = 0; i < keys.length; i++) {
+      const item = state[keys[i]];
+      isWrappable(item) && recursivelyAddParent(item[$RAW] || item, state);
+    }
+  }
 }
 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);
+  const unwrappedStore = unwrap(store);
+  let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
       Writing.add(unwrappedStore);
@@ -1332,8 +1381,14 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
+  if (derived)
+    return wrapProjection(first, wrappedStore, setStore);
   return [wrappedStore, setStore];
 }
+function deep(store) {
+  recursivelyAddParent(store[$RAW] || store);
+  return store[$DEEP];
+}
 
 // src/store/reconcile.ts
 function applyState(next, state, keyFn) {
@@ -1718,15 +1773,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 +1800,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;
 }
@@ -1764,4 +1848,4 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, untrack, unwrap };