My attempt at fixing PkvStore not being a resource. Not sure if it is possible to add something smaller than bevy_ecs to dependencies. The error is PkvStore: bevy::prelude::Resource is not satisfied for Res<PkvStore>, ResMut<PkvStore>, ect.

In some situation,it may need to clear kv data when logout app ,sled and localstorage both support clear function,so can you support it or can i create a PR?

On WASM, when I use pkv.set_string to store a string with a dot (.) in it (in the value, not in the key), it splits on the dot and stores an array instead. Needless to say, trying to load that value fails because the type is wrong.

This only happens with set_string - using set stores the value correctly.

This only happens on WASM - on native set_string works properly.

I'm using the version from the latest commit (02c18d117ff7a299ac6e439549aba242b81887bb)

There isn't that much bevy specific code in this crate.

Doing so would perhaps make the crate useful for other cross-platform game engines/apps as well.

If the same protocol-domain-port triplet is used by multiple libraries or apps, the keys may conflict with each other. i.e. it's currently probably a bad idea to use generic names like "user".

Perhaps it would make sense to add a store-wide setting for adding a prefix or "name" to keys in order to prevents collisions

Currently the sled db is created in the current working directory. It should probably be put in some meaningful folder depending on the platform.

Like $HOME/AppData/LocalLow/Developer/Game on windows and ~/.local/share/developer/game on linux.

~~The store is now a NonSend resource... which is a bit unfortunate, not sure what we can do about that... Maybe we can make it a special system param that is nonsend on wasm only?~~

~~The implementation is a bit messy now... Probably would be a good idea to move platform specific implementations into separate files...~~

The error types are currently different based on platform... Maybe not ideal?

The first time an application is run, using a default value appears clunky. Catching the NotFound Error is natural enough to have specific helpers for that case. There is also an argument that this is not an error and get should return an Result<Option<_>... sounds interesting.

Notice the examples are bad(delete those b4 someone copies them), they just roll through any errors by treating any error as the NotFound condition.

Similar to: https://github.com/hwchen/keyring-rs/issues/103

It would be nice if there were rust conventions surrounding these APIs, if you look at std they almost always returns an Option... noting the difference that IO errors are not a thing for HashMap.

    let h: PkvStore;

    let _limits: Option<Limits> =
        h.get("limits")
            .or_else(|x| -> Result<_, Box<dyn std::error::Error>> {
                if matches!(x, bevy_pkv::GetError::NotFound) {
                    h.set("limits", &Option::<Limits>::None)?;
                    Ok(None) /// Indicating the user has not seen the wizard for this.
                } else {
                    Err(x)?
                }
            })?;

    let _old_boot_id: Option<u64> = h.get("boot_id").map(Option::Some).or_else(
        |x| -> Result<_, Box<dyn std::error::Error>> {
            if matches!(x, bevy_pkv::GetError::NotFound) {
                Ok(None) /// Value set in next block.
            } else {
                Err(x)?
            }
        },
    )?;

    let boot_id: u64 = rand::thread_rng().gen();
    h.set("boot_id", &boot_id)?;

I think there are better ways to write this, suggestions welcome.

There's a hard limit on chrome of 5Mb which is utf16 so typically you'll have 2.5mb to play with.

IndexedDb seems to have a minimum of 10x the size by default but looks to be much bigger if you have a large storage size.

It would be great if there was a feature to use indexeddb.

It would be nice it was possible to customize what kind of serializer is used.

Currently it's hard-coded to rmp-serde (messagepack with struct maps) on native and serde_json on wasm.