fixed typos

Author: bennobuilder

docs/packages/core/features/collection/Introduction.md

@@ -269,15 +269,16 @@ which gives us much more freedom in configuring them.
 <br/>
 
 #### `key`
-The `key/name` is an optional property that is used to identify the Collection later.
-Such `key` is pretty useful during debug sessions or if we [persist](./Methods.md#persist) our Collection,
-it automatically uses the Collection `key` as persist key.
-We recommend giving each Collection a unique `key`, since it has only advantages.
+The optional property `key/name` should be a unique `string/number` to identify the Collection later.
 ```ts
 const MY_COLLECTION = App.createCollection({
   key: "myKey"
 });
 ```
+We recommend giving each Collection a unique `key`, since it has only advantages:
+- helps us during debug sessions
+- makes it easier to identify the Collection
+- no need for separate persist Key
 
 <br/>
 

docs/packages/core/features/collection/group/Introduction.md

@@ -104,7 +104,7 @@ MY_GROUP.value; // Returns '[1, 2, 3]'
 
 ### `config`
 
-Beside the initial îtemKeys a `Collection` takes an optional configuration object.
+Beside the initial îtemKeys a `Group` takes an optional configuration object.
 ```ts
 const MY_GROUP = MY_COLLECTION.createGroup([1, 2, 3], {
     key: "myGroup",
@@ -122,15 +122,16 @@ export interface GroupConfigInterface {
 <br/>
 
 #### `key`
-The `key/name` is an optional property that is used to identify the Group later.
-Such `key` is pretty useful during debug sessions or if we [persist](../../state/Methods.md#persist) our Group,
-it automatically uses the Group `key` as persist key.
-We recommend giving each Collection a unique `key`, since it has only advantages.
+The optional property `key/name` should be a unique `string/number` to identify the Group later.
 ```ts
 const MY_GROUP = MY_COLLECTION.createGroup([1, 2, 3], {
     key: "myKey"
 });
 ```
+We recommend giving each Group a unique `key`, since it has only advantages:
+- helps us during debug sessions
+- makes it easier to identify the Collection
+- no need for separate persist Key
 
 <br/>
 
@@ -142,16 +143,24 @@ This property is mainly thought for internal use.
 
 :::
 
-With `isPlaceholder` we tell our Group that it's a placeholder.
-Often Groups are `placeholder` when AgileTs needs to hold a reference to it,
-although the Group doesn't official exists and hasn't been instantiated yet.
+Defines whether the Group is an `placeholder` or not.
 ```ts
-const MY_STATE = App.createState("myInitialValue", {
+const MY_GROUP = App.createGroup([1, 2, 3], {
     isPlaceholder: true
 });
 
-MY_STATE.exists(); // false
+MY_GROUP.exists(); // false
 ```
+Groups are, for example, `placeholder` when AgileTs needs to hold a reference to them,
+although they aren't instantiated yet.
+This might be the case by using `getGroupWithReference()`, 
+where AgileTs returns a `placeholder` Group, if the Group doesn't exist,
+to hold a reference to the not existing Group.
+```ts
+useAgile(getGroupWithReference(1));
+```
+This reference is important to rerender the Component, 
+whenever the Group got instantiated.
 
 
 ## 🟦 Typescript

docs/packages/core/features/collection/selector/Introduction.md

@@ -76,10 +76,70 @@ Test the Selector yourself, it's only one click away. Just select your preferred
 ## 📭 Props
 
 ### `itemKey`
-TODO
+The `itemKey` of the Item the Selector represents
+```ts {1}
+const MY_SELECTOR = MY_COLLECTION.createSelector(1);
+```
 
 ### `config`
-TODO
+
+Beside the initial itemKey a `Selector` takes an optional configuration object.
+```ts
+const MY_SELECTOR = MY_COLLECTION.createSelector(1, {
+    key: "mySelector",
+});
+```
+Here is a Typescript Interface for quick reference. However,
+each property is explained in more detail below.
+```ts
+export interface SelectorConfigInterface {
+    key?: SelectorKey;
+    isPlaceholder?: boolean;
+}
+```
+
+<br/>
+
+#### `key`
+The optional property `key/name` should be a unique `string/number` to identify the Selector later.
+```ts
+const MY_GROUP = MY_COLLECTION.createGroup([1, 2, 3], {
+    key: "myKey"
+});
+```
+We recommend giving each Selector a unique `key`, since it has only advantages:
+- helps us during debug sessions
+- makes it easier to identify the Collection
+- no need for separate persist Key
+
+<br/>
+
+#### `isPlaceholder`
+
+:::warning
+
+This property is mainly thought for internal use.
+
+:::
+
+Defines whether the Selector is an `placeholder` or not.
+```ts
+const MY_SELECTOR = App.creaateSelector(1, {
+    isPlaceholder: true
+});
+
+MY_SELECTOR.exists(); // false
+```
+Selector are, for example, `placeholder` when AgileTs needs to hold a reference to them,
+although they aren't instantiated yet.
+This might be the case by using `getSelectorWithReference()`,
+where AgileTs returns a `placeholder` Selector, if the Selector doesn't exist,
+to hold a reference to the not existing Selector.
+```ts
+useAgile(getSelectorWithReference(1));
+```
+This reference is important to rerender the Component,
+whenever the Selector got instantiated.
 
 
 ## 🟦 Typescript

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

@@ -95,15 +95,16 @@ export interface StateConfigInterface {
 <br/>
 
 #### `key`
-The `key/name` is an optional property that is used to identify the State later.
-Such `key` is pretty useful during debug sessions or if we [persist](./Methods.md#persist) our State,
-it automatically uses the State `key` as persist key.
-We recommend giving each State a unique `key`, since it has only advantages.
+The optional property `key/name` should be a unique `string/number` to identify the State later.
 ```ts
 const MY_STATE = App.createState("myInitialValue", {
     key: "myKey"
 });
 ```
+We recommend giving each State a unique `key`, since it has only advantages:
+- helps us during debug sessions
+- makes it easier to identify the Collection
+- no need for separate persist Key
 
 <br/>
 
@@ -134,16 +135,16 @@ This property is mainly thought for internal use.
 
 :::
 
-With `isPlaceholder` we tell our State that it's a placeholder.
-Often States are `placeholder` when AgileTs needs to hold a reference to it, 
-although the State doesn't official exists and hasn't been instantiated yet.
+Defines whether the State is an `placeholder` or not.
 ```ts
 const MY_STATE = App.createState("myInitialValue", {
     isPlaceholder: true
 });
 
 MY_STATE.exists(); // false
 ```
+States are, for example, `placeholder` when AgileTs needs to hold a reference to them,
+although they aren't instantiated yet.
 
 ## 🟦 Typescript