Sadly, {reactive: false} is of no help here. The update operation I am talking about modifies specific fields in my Collection and is executed at a specific time (I have some other updates, which I want to be reactive). If I put {reactive: false} on my cursors, I end up with no reactivity at all, which is not what I want.
Why I don’t understand is why Tracker.nonreactive(function() { localCollection.update(id, { $set: fields }); }); doesn’t work. It is a purely local and synchronous operation (isn’t it?).
Might this be a bug?
Tracker.nonreactive makes the reactive variables in the function you passed to it non reactive, so they don’t causes any re-runs to a function passed to Tracker.autorun, so it doesn’t work like you want/think. But I agree with @zachdixon; set the reactive option to false. If you need reactivity for some of the fields, use two calls to find (one reactive, and one non reactive).
@Peppe_LG, thanks for the explanation about Tracker.autorun, it is clearer now.
Regarding your suggestion, while I can see how to combine two calls to findOne to build a single result, I am not sure you can do the same with two calls to find…
I’m not sure either. I guess the optimal solution for this depends on the context. Can you show us where you use the find that should be partly reactive and partly non reactive?
I found a solution in my specific context, but it is less elegant than what I wanted.
My context is text edition: I have a list of textareas corresponding to Collection records. While user is typing, I want to update the Collection at fixed interval, but I cannot afford to refresh the DOM otherwise textarea focus and caret are lost.
This is what I have implemented in the past, although with findOne in a helper rather than in transform. However, it seems having a reactive cursor returning hundreds of texteareas, each one having its own individual reactive cursors, lead to poor performance. I didn’t measure it precisely, though.
I tried another solution: mirroring my collection in a local collection using observeChange. This allows avoiding the copy of the non-reactive fields over to the local collection, hence preventing reactivity. It seemed better in terms of performance, but the mirroring logic is delicate and error-prone (avoiding to copy a field over is easy, but the problem is to decide when you finally want to copy it over so that your local collection is up to date).