Subscribing to a null-able branch

[alexander-entin]

I want to be notified of any changes in a given branch, including when it's deleted and recreated:

// Attempt #1
p = proxy({ a: { b: 1 } })
subscribe(p.a, () => console.log('change'))
p.a.b = 2
// -> change
p.a = null
// oops, no notification

// Attempt #2
p = proxy({ a: { b: 1 } })
subscribeKey(p, 'a', () => console.log('change'))
p.a = null
// -> change
p.a = { b: 1 }
// -> change
p.a.b = 2
// oops, no notification

So, neither subscribe nor subscribeKey help.
I'm about to use this instead:

const subscribeBranch = (proxy, key, fn, ...rest) => subscribe(proxy, ops => {
    ops = ops.filter(([_, path]) => path[0] === key)
    ops.length && fn(ops)
}, ...rest)

And my questions:

1. Am I missing an existing way to do the same?
2. Is this a good implementation?
3. Is it a good idea to change the current behavior of subscribeKey to this one? Or to add a separate utility?

Thank you

[dai-shi]

I would do this:

let prev;
subscribe(p, () => {
  const curr = snapshot(p).a
  if (prev !== curr) {
    console.log('changed');
    prev = curr;
  }
});

See also: #554

[alexander-entin]

Interesting.. So, I've generalized this to a utility:

const prevMap = new WeakMap()
const subscribeBranch = (proxy, key, fn, ...rest) => {
  let prev = prevMap.get(proxy)
  if (!prev) {
    prev = {}
    prevMap.set(proxy, prev)
  }
  prev[key] = snapshot(proxy)[key]
  return subscribe(proxy, () => {
    const curr = snapshot(proxy)[key]
    if (curr !== prev[key]) {
      fn()
    }
    prev[key] = curr
  }, ...rest)
}

Can you elaborate on why do you prefer this approach to the one from the starter post?
Is there a plan to remove operations list from subscribe callback?
Am I right assuming that snapshotting an array will copy it and thus (at most) double the memory usage?

Thank you.

UPD.
Ah, looking into the implementation, I see, that snapshot is cached anyway, so this one will not make any difference in memory usage.

UPD 2
It looks like I've complicated it unnecessarily, and this will do:

subscribeBranch = (proxy, key, fn, ...rest) => {
  let prev = snapshot(proxy)[key]
  return subscribe(proxy, (...ops) => {
    const curr = snapshot(proxy)[key]
    if (curr !== prev) {
      fn(...ops)
      prev = curr
    }
  }, ...rest)
}

[dai-shi]

Is there a plan to remove operations list from subscribe callback?

No, but it's basically for advanced users or library authors.