Configuration of two the root instances separately

[tokarchyn]

I'm writing a library for React, which use MobX for state management. For this library, I want to disable strict mode (especially actions enforcing). The only way of doing it I found, is global configuration using function like this:

import { configure } from "mobx"

configure({
    enforceActions: "never"
})

But in this case, configuration will be applied for entire application that use my library, therefore, a developer of this application, if he also wants use MobX, will be forced to use configuration that I chose (if not, he will retrieve warnings).

So my question is, if there is a way to configure MobX in my library, so it will not affect the entire application, where the library is used?

[danielkcz]

No there is no way. Best to provide a recommendation to users of your library on how to configure mobx. Do not configure mobx in the library really. Nobody will thank you for that confusion.

What is even your reason to disable strict mode? Sounds a bit of a design problem if your library can't handle strict mode well.

[tokarchyn]

Of course, if it is not possible to configure only instances of my library, I will not do this. But still, it makes me sad that MobX does not provide the way to do it. I don't see any reason why the plain variable declaration id: string; is worse than:

private _id: string;

get id() {
  return this._id;
}

set id(value: string){
  this._id = value
}

It is really exhausting to write that much of code and also to read through it.

[danielkcz]

@mweststrate @urugator Some ideas here I might have missed?

[urugator]

Have you tried configure({ isolateGlobalState: true })?

[urugator]

I don't see any reason why the plain variable declaration id: string; is worse than:

It's more about function call vs assigment, but whatever. You have to make compromises ... what do you value more?
a) ability to expose properties as your API
b) warning about forgotten action that could lead to poor perf
You can't get both.

Similary, the global shared state has some advantages: multiple code bases can share single mobx instance, multiple compatible mobx instances can work together (reaction from one reacts to observables from other), you can simply import things instead of something like const myMobx = new Mobx(); myMobx.observable; myMobx.reaction(); (which would also prevent tree shaking - unless you would split it to factories const myReactionFactory = reactionFactory(myMobx)) etc.
And there are disadvantages as well, like shared configuration...

[mweststrate]

the point of actions is not to wrap individual mutations, but rather the entire event that causes the update. If you are trying to x.age = 14; x.name = "test", and you want to wrap both setters in an action; then you are still not benefiting from actions. The point is that the entire block of updates should be a single transaction, which is generally achieve by having your event handlers (dom events, websocket messages, any async scheduling) wrapped in actions. Then the getters / setters actually don't really need need them.