@solidjs/signals 0.13.12 → 0.13.13

package/dist/dev.js

@@ -1081,6 +1081,7 @@ function handleAsync(el, result, setter) {
     if (el._inFlight !== result) return;
     if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
     globalQueue.initTransition(resolveTransition(el));
+    const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
@@ -1094,9 +1095,10 @@ function handleAsync(el, result, setter) {
       }
       el._time = clock;
     } else if (lane) {
+      const isEffect = el._type;
       const prevValue = el._value;
       const equals = el._equals;
-      if (!equals || !equals(value, prevValue)) {
+      if ((!isEffect && wasUninitialized) || !equals || !equals(value, prevValue)) {
         el._value = value;
         el._time = clock;
         if (el._latestValueComputed) {
@@ -1359,6 +1361,7 @@ function recompute(el, create = false) {
   const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
   const wasPending = !!(el._statusFlags & STATUS_PENDING);
+  const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -1424,7 +1427,8 @@ function recompute(el, create = false) {
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
-    const valueChanged = !el._equals || !el._equals(compareValue, value);
+    const valueChanged =
+      (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
     if (valueChanged) {
       const prevVisible = hasOverride ? el._overrideValue : undefined;
       if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty) {
@@ -2690,12 +2694,55 @@ function getKeys(source, override, enumerable = true) {
   return Array.from(keys);
 }
 function getPropertyDescriptor(source, override, property) {
-  let value = source;
   if (override && property in override) {
-    if (value[property] === $DELETED) return void 0;
-    if (!(property in value)) value = override;
+    if (override[property] === $DELETED) return void 0;
+    const overrideDesc = Reflect.getOwnPropertyDescriptor(override, property);
+    if (overrideDesc?.get || overrideDesc?.set || !(property in source)) return overrideDesc;
   }
-  return Reflect.getOwnPropertyDescriptor(value, property);
+  return Reflect.getOwnPropertyDescriptor(source, property);
+}
+function prepareStoreWrite(target, store, property) {
+  if (target[STORE_OPTIMISTIC]) {
+    const firewall = target[STORE_FIREWALL];
+    if (firewall?._transition) {
+      globalQueue.initTransition(firewall._transition);
+    }
+  }
+  const state = target[STORE_VALUE];
+  const base = state[property];
+  if (
+    snapshotCaptureActive &&
+    typeof property !== "symbol" &&
+    !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
+  ) {
+    if (!target[STORE_SNAPSHOT_PROPS]) {
+      target[STORE_SNAPSHOT_PROPS] = Object.create(null);
+      snapshotSources?.add(target);
+    }
+    if (!(property in target[STORE_SNAPSHOT_PROPS])) {
+      target[STORE_SNAPSHOT_PROPS][property] = base;
+    }
+  }
+  const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
+  const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+  if (useOptimistic) trackOptimisticStore(store);
+  return { base: base, overrideKey: overrideKey, state: state };
+}
+function notifyStoreProperty(target, property, mode, value) {
+  if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], mode !== "delete");
+  const nodes = getNodes(target, STORE_NODE);
+  if (mode === "set") {
+    nodes[property] &&
+      setSignal(nodes[property], () => (isWrappable(value) ? wrap(value, target) : value));
+  } else if (mode === "invalidate") {
+    if (nodes[property]) {
+      setSignal(nodes[property], {});
+      delete nodes[property];
+    }
+  } else {
+    nodes[property] && setSignal(nodes[property], undefined);
+  }
+  nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
 }
 let Writing = null;
 const storeTraps = {
@@ -2808,31 +2855,12 @@ const storeTraps = {
   set(target, property, rawValue) {
     const store = target[$PROXY];
     if (writeOnly(store)) {
-      if (target[STORE_OPTIMISTIC]) {
-        const firewall = target[STORE_FIREWALL];
-        if (firewall?._transition) {
-          globalQueue.initTransition(firewall._transition);
-        }
-      }
       untrack(() => {
-        const state = target[STORE_VALUE];
-        const base = state[property];
-        if (
-          snapshotCaptureActive &&
-          typeof property !== "symbol" &&
-          !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
-        ) {
-          if (!target[STORE_SNAPSHOT_PROPS]) {
-            target[STORE_SNAPSHOT_PROPS] = Object.create(null);
-            snapshotSources?.add(target);
-          }
-          if (!(property in target[STORE_SNAPSHOT_PROPS])) {
-            target[STORE_SNAPSHOT_PROPS][property] = base;
-          }
-        }
-        const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
-        const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-        if (useOptimistic) trackOptimisticStore(store);
+        const {
+          base: base,
+          overrideKey: overrideKey,
+          state: state
+        } = prepareStoreWrite(target, store, property);
         const prev =
           target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
             ? target[STORE_OPTIMISTIC_OVERRIDE][property]
@@ -2858,21 +2886,46 @@ const storeTraps = {
           override[property] = value;
           if (nextLength !== undefined) override.length = nextLength;
         }
-        const wrappable = isWrappable(value);
-        target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] &&
-          setSignal(nodes[property], () => (wrappable ? wrap(value, target) : value));
+        notifyStoreProperty(target, property, "set", value);
         if (Array.isArray(state)) {
+          const nodes = getNodes(target, STORE_NODE);
           const lengthValue = property === "length" ? value : nextLength;
           lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
         if (true) DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
       });
     }
     return true;
   },
+  defineProperty(target, property, descriptor) {
+    const store = target[$PROXY];
+    if (writeOnly(store)) {
+      untrack(() => {
+        const { base: base, overrideKey: overrideKey } = prepareStoreWrite(target, store, property);
+        const normalizedDescriptor =
+          "value" in descriptor
+            ? {
+                ...descriptor,
+                value: descriptor.value?.[$TARGET]?.[STORE_VALUE] ?? descriptor.value
+              }
+            : descriptor;
+        Object.defineProperty(
+          target[overrideKey] || (target[overrideKey] = Object.create(null)),
+          property,
+          normalizedDescriptor
+        );
+        notifyStoreProperty(target, property, "invalidate");
+        if (true) {
+          const next =
+            "value" in normalizedDescriptor
+              ? normalizedDescriptor.value
+              : normalizedDescriptor.get?.call(store);
+          DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, next, base);
+        }
+      });
+    }
+    return true;
+  },
   deleteProperty(target, property) {
     const optDeleted = target[STORE_OPTIMISTIC_OVERRIDE]?.[property] === $DELETED;
     const regDeleted = target[STORE_OVERRIDE]?.[property] === $DELETED;
@@ -2895,10 +2948,7 @@ const storeTraps = {
         } else if (target[overrideKey] && property in target[overrideKey]) {
           delete target[overrideKey][property];
         } else return true;
-        if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], false);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], undefined);
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
+        notifyStoreProperty(target, property, "delete");
       });
     }
     return true;
@@ -2920,6 +2970,8 @@ const storeTraps = {
     if (property === $PROXY) return { value: target[$PROXY], writable: true, configurable: true };
     if (target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]) {
       if (target[STORE_OPTIMISTIC_OVERRIDE][property] === $DELETED) return undefined;
+      const optDesc = Reflect.getOwnPropertyDescriptor(target[STORE_OPTIMISTIC_OVERRIDE], property);
+      if (optDesc?.get || optDesc?.set || !(property in target[STORE_VALUE])) return optDesc;
       const baseDesc = getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
       if (baseDesc) {
         return { ...baseDesc, value: target[STORE_OPTIMISTIC_OVERRIDE][property] };
@@ -3113,7 +3165,12 @@ function updatePath(current, args, i = 0) {
   ) {
     const target = part !== undefined ? current[part] : current;
     const keys = Object.keys(value);
-    for (let i = 0; i < keys.length; i++) target[keys[i]] = value[keys[i]];
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = Object.getOwnPropertyDescriptor(value, key);
+      if (desc.get || desc.set) Object.defineProperty(target, key, desc);
+      else target[key] = desc.value;
+    }
   } else {
     current[part] = value;
   }