simplyflow 0.2.3 → 0.3.1

package/src/state.mjs

@@ -2,12 +2,18 @@ const iterate = Symbol('iterate')
 if (!Symbol.xRay) {
     Symbol.xRay = Symbol('xRay')
 }
+if (!Symbol.Signal) {
+    Symbol.Signal = Symbol('Signal')
+}
 
 const signalHandler = {
     get: (target, property, receiver) => {
         if (property===Symbol.xRay) {
             return target // don't notifyGet here, this is only called by set
         }
+        if (property===Symbol.Signal) {
+            return true
+        }
         const value = target?.[property] // Reflect.get fails on a Set.
         notifyGet(receiver, property)
         if (typeof value === 'function') {
@@ -116,12 +122,40 @@ const signals = new WeakMap()
  * to allow reactive functions to be triggered when signal values change.
  */
 export function signal(v) {
-    if (!signals.has(v)) {
+    if (v[Symbol.Signal]) { // avoid wrapping a Signal inside a Signal
+        let target = v[Symbol.xRay]
+        if (!signals.has(target)) {
+            signals.set(target, v)
+        }
+        v = target
+    } else if (!signals.has(v)) {
         signals.set(v, new Proxy(v, signalHandler))
     }
     return signals.get(v)
 }
 
+/**
+ * Lists all effects that are currently listening to changes in
+ * the given signal and property
+ * returns a list with 
+ * - effect: the effect function (effect, throttledEffect, clockEffect)
+ * - fn: the user provided function to this effect function
+ * - signal: the connectedSignal to this user provided function
+ * @param Signal signal
+ * @param string prop 
+ * @return array of { effect, fn, signal }
+ */
+export function trace(signal, prop) {
+    const listeners = getListeners(signal, prop)
+    return listeners.map(listener => {
+        return {
+            effect: listener.effectType,
+            fn: listener.effectFunction,
+            signal: signals.get(listener.effectFunction)
+        }
+    })
+}
+
 let batchedListeners = new Set()
 let batchMode = 0
 /**
@@ -308,6 +342,8 @@ export function effect(fn) {
         }
         // remove all dependencies (signals) from previous runs 
         clearListeners(computeEffect)
+        computeEffect.effectFunction = fn
+        computeEffect.effectType = effect
         // record new dependencies on this run
         computeStack.push(computeEffect)
         // prevent recursion
@@ -437,6 +473,8 @@ export function throttledEffect(fn, throttleTime) {
         // remove all dependencies (signals) from previous runs 
         clearListeners(computeEffect)
         // record new dependencies on this run
+        computeEffect.effectFunction = fn
+        computeEffect.effectType = throttledEffect
         computeStack.push(computeEffect)
         // prevent recursion
         signalStack.push(connectedSignal)
@@ -493,6 +531,8 @@ export function clockEffect(fn, clock) {
             if (hasChanged) {
                 // remove all dependencies (signals) from previous runs 
                 clearListeners(computeEffect)
+                computeEffect.effectFunction = fn
+                computeEffect.effectType = clockEffect
                 // record new dependencies on this run
                 computeStack.push(computeEffect)
                 // make sure the clock.time signal is a dependency