fixed some typos

Author: bennobuilder

docs/packages/core/features/state/Methods.md

@@ -207,11 +207,13 @@ Returns the [State](../state/Introduction.md) it was called on.
 
 :::info
 
-Only useful if we use the [`type`](#type) function.
+Only useful if we have used the [`type`](#type) function to define the type of our State.
 
 :::
 
-Checks if passed value has correct value type, defined with the [`type`](#type) function.
+Checks if the given value has the correct type at runtime.
+It compares whether the value has the same type, which was previously 
+defined with help of the [`type`](#type) function.
 ```ts {2,3}
 MY_STATE.type(String);
 MY_STATE.hasCorrectType("hi"); // Returns 'true'
@@ -233,8 +235,8 @@ MY_STATE.hasCorrectType(12); // Returns 'false'
 
 ## `undo`
 
-Reverses our latest State Value mutation.
-Be aware that it can only reverses one State change,
+Reverses the latest State Value mutation.
+Be aware that it can only reverses one State change at once,
 that's why we can't do `undo().undo().undo()` to get to the State Value from before 3 State changes.
 ```ts {3}
 MY_STATE.set("hi"); // State Value is 'hi'
@@ -263,9 +265,7 @@ Returns the [State](../state/Introduction.md) it was called on.
 
 ## `reset`
 
-Resets our State Value to its initial Value.
-If you are wondering what the initial Value is,
-it is the Value which was firstly assigned to our State.
+Sets the State Value to its initial Value.
 ```ts {4}
 const MY_STATE = App.createState("hi"); // State Value is 'hi'
 MY_STATE.set("bye"); // State Value is 'bye'
@@ -296,11 +296,11 @@ Returns the [State](../state/Introduction.md) it was called on.
 
 :::info
 
-Only relevant for State Values which have `object` as type.
+Only relevant for States which have an `object` as value type.
 
 :::
 
-Merges an object with changes into the current State Value.
+Merges an object into the current State Value object.
 ```ts {2,5}
 const MY_STATE = App.createState({id: 1, name: "frank"}); // State Value is '{id: 1, name: "frank"}'
 MY_STATE.patch({name: "jeff"}); // State Value is '{id: 1, name: "jeff"}'
@@ -311,13 +311,14 @@ MY_STATE.patch({hello: "there"}); // Error
 
 ### ❓ Deepmerge
 Unfortunately the `patch` function doesn't support deep merges yet. 
-Currently, the merge only happens at the top-level of our Objects, and it doesn't look for deep changes.
-If it cannot find a particular property, it will add it to the top-level of the object.
+Currently, the merge only happens at the top-level of our objects.
+This means, that it doesn't look for deep changes,
+if it cannot find a particular property, it will add it at the top-level of the object.
 ```ts {2}
 const MY_STATE = App.createState({things: { thingOne: true, thingTwo: true }}); // State Value is {things: { thingOne: true, thingTwo: true }}
 MY_STATE.patch({ thingOne: false }); // State Value is {things: { thingOne: true, thingTwo: true }, thingOne: false}
 ```
-If we don't want to add not existing properties to our State Value object, we can set `addNewProperties` to _false_.
+If we don't want to add not existing properties to the object, we can set `addNewProperties` to _false_.
 ```ts {2}
 const MY_STATE = App.createState({things: { thingOne: true, thingTwo: true }}); // State Value is {things: { thingOne: true, thingTwo: true }}
 MY_STATE.patch({ thingOne: true }, {addNewProperties: false}); // State Value is {things: { thingOne: true, thingTwo: true }}
@@ -346,7 +347,7 @@ Returns the [State](../state/Introduction.md) it was called on.
 ## `watch`
 
 Observes our State and calls a callback function on each State Value mutation.
-```ts
+```ts {1-4}
 const response = MY_STATE.watch((value, key) => {
     console.log(value); // Returns current State Value
     console.log(key); // Key of Watcher ("Aj2pB")
@@ -355,19 +356,19 @@ const response = MY_STATE.watch((value, key) => {
 console.log(response); // "Aj2pB" Random generated Key to idetify the watcher callback
 ```
 We recommend giving each `watcher` callback a unique key to properly identify it later.
-```ts
+```ts {1-3}
 const something = MY_STATE.watch("myKey", (value) => {
   // do something
 });
 
 console.log(response); // State Instance it was called on
 ```
 A proper identification is for instance necessary, 
-if we want to clean up our watcher callback to avoid memory leaks.
+to clean up our watcher callback later.
 
 ### ❓ When should I cleanup
-If we need to use our watcher in component code, it is important to [clean up](#removewatcher), as if
-the component unmounts, and the watcher remains it can cause memory leaks.
+If we have to use a watcher in component code, it is important to [clean up](#removewatcher) after using it. 
+Because if the component unmounts, and the watcher remains it can cause memory leaks.
 ```ts
 MY_STATE.removeWatcher(cleanupKey);
 ```
@@ -410,9 +411,8 @@ Otherwise, it generates us a random Key and returns this.
 ## `removeWatcher`
 
 Removes `watcher` callback at specific Key.
-Such a cleanup is important, after we have no reason to use the callback
-anymore. For instance after a Component has been unmounted, we should cleanup
-the callback to avoid memory leaks.
+Such a cleanup is important, after we have no reason to use the watcher callback anymore. 
+For instance after a Component has been unmounted to avoid memory leaks.
 ```ts
 MY_STATE.removeWatcher("myKey");
 ```
@@ -496,9 +496,8 @@ Returns the [State](../state/Introduction.md) it was called on.
 
 ## `persist`
 
-Preserves State Value in the appropriate local storage 
-for the current environment. No matter if Mobile or Web
-environment as long as we have configured our [Storage](../storage/Introduction.md) correctly.
+Preserves State Value in the appropriate local storage for the current environment. 
+No matter if Mobile or Web environment as long as we have configured our [Storage](../storage/Introduction.md) correctly.
 ```ts
 MY_STATE.perist("myPersistKey");
 ```
@@ -511,6 +510,7 @@ const App = new Agile({
   localStorage: true
 })
 ```
+So there is noting to setup here.
 
 ### 📱 Mobile
 In the mobile environment the Local Storage unfortunately doesn't exist,
@@ -526,13 +526,13 @@ App.registerStorage(
       set: AsyncStorage.setItem,
       remove: AsyncStorage.removeItem,
     },
-  })
+  }), {default: true}
 );
 ```
 
 ### 🔑 Local Storage Key
-If we want to persist our State, 
-we have two options to provide the `persist` function a required Storage Key.
+To persist our State, 
+we have two options to provide the `persist` function the **required** Storage Key.
 
 - **1.** Assign a unique Key to our State,
   because if no key was given to the `persist` function, 
@@ -546,21 +546,21 @@ we have two options to provide the `persist` function a required Storage Key.
   MY_STATE.persist("myCoolKey"); // Success
   ```
 
-If AgileTs couldn't find any Key, it drops an error and doesn't persist the State Value.
+If AgileTs couldn't find any key, it drops an error and doesn't persist the State Value.
 ```ts {2}
 MY_STATE.key = undefined;
 MY_STATE.persist(); // Error
 ```
 
 ### 📝 Multiple Storages
-If our Application for whatever reason has two registered Storages that get actively used. 
-And we don't want to store our State Value in the default Storage, which gets automatically used by the `perist` function.
-We can define the Storages it should use instead in the `config` object.
-```ts
+If our Application for whatever reason has more than one registered Storages that get actively used. 
+We can define with help of the `storageKeys` in which Storage the `persist` function stores the State Value. 
+```ts {2}
 MY_STATE.persist({
 storageKeys: ["myCustomStorage"]
 })
 ```
+By default, it gets stored in the default Storage.
 
 ### 📭 Props
 
@@ -590,8 +590,8 @@ MY_STATE.onLoad((success) => {
 console.log(`Value '${MY_STATE.value}' got loaded into the State! Success? ${success}`)
 });
 ```
-For instance this might be useful, if we want to show a loading indicator until
-we are able to show the persisted Value.
+For instance this might be useful, to show a loading indicator until
+the persisted Value got loaded.
 
 ### 📭 Props
 
@@ -656,12 +656,12 @@ MY_STATE.exists; // Returns 'true'
 
 ## `is`
 
-Checks if the State Value _is equal_ to a specific value.
+Checks if the State Value _is equal_ to the provided value.
 Equivalent to `===`.
 ```ts {2,3}
 const MY_STATE = App.createState("hi");
-MY_STATE.is("bye"); // Returns false
-MY_STATE.is("hi"); // Returns true
+MY_STATE.is("bye"); // Returns 'false'
+MY_STATE.is("hi"); // Returns 'true'
 ```
 
 ### 📭 Props
@@ -685,12 +685,12 @@ MY_STATE.is("hi"); // Returns true
 
 ## `isNot`
 
-Checks if the State Value _isn't equal_ to a specific value.
+Checks if the State Value _isn't equal_ to the provided value.
 Equivalent to `!==`.
 ```ts {2,3}
 const MY_STATE = App.createState("hi");
-MY_STATE.isNot("bye"); // Returns true
-MY_STATE.isNot("hi"); // Returns false
+MY_STATE.isNot("bye"); // Returns 'true'
+MY_STATE.isNot("hi"); // Returns 'false'
 ```
 
 ### 📭 Props
@@ -716,7 +716,7 @@ MY_STATE.isNot("hi"); // Returns false
 
 :::info
 
-Only relevant for State Values which have `boolean` as type.
+Only relevant for States which have an `boolean` as value type.
 
 :::