How setup reactions over new entries on map without use ( intercept | observe )

[omenlog]

I have an observable map peopleMap which is a map indexed by person ids and contain as values person (id, name, email) objects. There are specific reactions for every property of a person in the map, I mean a change in person.name trigger a different reaction that a change on person.email. I implemented the reactions for a new person added in our map in the following way:

import {when, observable, intercept, reaction, ObservableMap } from 'mobx';

class Store {
    peopleMap: ObservableMap<number, Person>;

    constructor() {
        this.peopleMap = observable.map();
        this.setInterception();
    }

    setPersonReactions(personId) {
        const person = this.peopleMap.get(personId);

        reaction(() => person.name, () => {/* name reaction */ })
        reaction(() => person.email, () => {/* email reaction */ })

       /*  ignored reaction disposer handling in this snippet for sake of simplicity  */
    }

    setInterception() {
        intercept(this.peopleMap, change => {
            if (change.type === "add") {
                const personId = change.name;
                when(
                    () => this.peopleMap.get(personId) !== undefined,
                    () => this.setPersonReactions(personId)
            }

            return change;
        });
    }
}

with this code when I execute this.peopleMap.set(1, newPerson) , I get correctly the specific reactions for every property of this newPerson, the idea is get this reactions automatically just after add a new person.

The questions are as intercept is described as an antipattern in mobx official documentation

• this should be done in a different way ?
• is a bad idea use intercept in this case based, that it doesn't respect transactions ?

Thanks in advance.

[mweststrate]

I think the easiest way is to set up a reaction that listens to this.peopleMap.keys(). (You might need () => [...this.peopleMap.keys()], IIRC keys only returns an iterator object, not the actual keys)

[omenlog]

Yes, you are right keys() return an iterator and not the actual keys, this approach indeed gives us the keys updated when we add a new one.

But what I trying to do is get the new key and at the same time not run expensive derivations associated with the previous one, for example, if we have a list with [1,2], derivations executed for 1 and 2, then when I add 3 run only derivations for 3 and not for the whole list.

How would you do that?