Unable to set atom inital value as object

[Kaijonsson]

Bug Description

I'm strugging with the very basic task to provide a type and an initial value to an atom.

it works perfectly fine when you have arrays or booleans. Simple types.

This works perfectly:

export const test = atom<string>('test')

But when creating an object with some values, breaks the typeing.

type Test= {
  test: string
  value: boolean
}

export const test = atom<Test>({})

This example gives an error like this when trying to provide an initial value to the atom:

No overload matches this call.
Overload 1 of 4, '(read: Read<Test, never>): Atom', gave the following error.
Argument of type '{}' is not assignable to parameter of type 'Read<Test, never>'.
Type '{}' provides no match for the signature '(get: Getter, options: { readonly signal: AbortSignal; readonly setSelf: never; }): Test'.
Overload 2 of 4, '(initialValue: Test): PrimitiveAtom & WithInitialValue', gave the following error.
Argument of type '{}' is not assignable to parameter of type 'Test'.
Type '{}' is missing the following properties from type 'Test': test, valuets(2769)

I don't know if i've missed something in the tutorial/docs?
Hope you find all that you need in this report.
All the best
/Kaijonsson

Reproduction Link

can be tested in any jotai project.

[dai-shi]

I think this is probably what you want: https://tsplay.dev/WKlxpw

import { atom } from "jotai";

type Test = {
  test?: string;
  value?: boolean;
};

export const test = atom<Test>({});

[Kaijonsson]

indeed that works. But why do i have to make it conditional? I should be able to make a state not possibly undefined?

[dai-shi]

It's the same without Jotai. Does this https://tsplay.dev/WJkzVw help?

[Kaijonsson]

yeah, it's similar to how i solved it:

export const articleAtom = atom({} as SingleArticle)

Maybe it's just me who's used to doing it like this :
fun<type>()

Since the other solutions work i gues it's not a bug.

[rothsandro]

yeah, it's similar to how i solved it:
export const articleAtom = atom({} as SingleArticle)

This initializes the atom with an empty object {} but tells TypeScript it's a valid SingleArticle object (which it isn't, assuming it has required properties). There will be a runtime error if you ever try to access the atom value before it's initialized.

Maybe it's just me who's used to doing it like this :
fun<type>()

You can do this with Jotai as well: atom<SingleArticle>(). This will create an atom of type SingleArticle | undefined with undefined being the default value. In contrast to your type-casting this is type-safe, i.e. requires you to check whether the atom has a value or not before using it.

const articleAtom = atom<SingleArticle>();
//    ^? PrimitiveAtom<SingleArticle | undefined>;

// In the component
const value = useAtomValue(articleAtom);
//    ^? SingleArticle | undefined

[DavidJFelix]

I think casting an object as your type is not really better than a ts-ignore statement. You ought to type the atom correctly:

type Test= {
  test: string
  value: boolean
}

// We allow {} as the default
export const test = atom<Test | {}>({})

or provide a sensible default like so:

type Test= {
 test: string
 value: boolean
}

const defaultTest: Test = {
 test: "",
 value: false
}
export const test = atom<Test>(defaultTest)

An empty object does not satisfy the type you're telling the atom that it is. With the optional parameters, suggested above, it does. If optional parameters are not desirable, I'd say you want one of the two I'm advising.

Aside:

type Test = {
  test?: string;
  value?: boolean;
};
export const test = atom<Test>({});

as recommended above could also be written as:

type Test = {
 test: string;
 value: boolean;
};
export const test = atom<Partial<Test>>({});