Atom getter/initial value called again with Jotai Scope

[sndrrth]

Hi,

An atom with a getter atom(() => Date.now()) is by default only called once and then cached.
When the same atom is also used as a child of a ScopeProvider (jota-scope), the getter is called again even if this atom is not scoped. This also happens with atomWithDefault().

const foo = atom(() => Date.now());

<ComponentThatUsesFoo />       { /* Calls the atom getter */ }
<ComponentThatUsesFoo />       { /* Reuses the cached value /* }
<ScopeProvider atoms={[]}>
  <ComponentThatUsesFoo />     { /* Calls the atom getter again */ }
</ScopeProvider>

Idk, maybe this is needed because the atom could depend on a scoped atom... Is this a bug or the expected behavior?

We recently added Jotai Scope to our app and this resulted in a bug with existing atoms (that are not scoped). Our getter is used to create the initial value which is then expected to be shared across all usages of the atom.

[dai-shi]

I'd say it's a designed behavior.
Though, it's unfortunate our API doesn't cover some cases like lazy initialization for primitive atoms and eager initialization for read-only atoms. It's a design limitation. (We might add some new api to cover those, but they are mostly rare cases.)

I'm not 100% sure if I understand your problem with jotai-scope, but I think the following is a workaround.

const now = Date.now();
const foo = atom(() => now);

[sndrrth]

Thanks for answer 👍

The date value was just to demonstrate the idea, in real our atom holds the instance of a class that mutates it internal state - and that breaks if the instance is created twice. But the code probably isn't ideal anyway 😄 As long as we don't use multiple Jotai Providers (which should not share the instance), your workaround should work for us. Thanks a lot.