added doc search sub page

Author: bennobuilder

docs/other/DocSearch.md

@@ -0,0 +1,15 @@
+---
+id: interfaces
+title: Interfaces
+sidebar_label: Interfaces
+slug: /docsearch
+---
+
+Hello `docsearch` Team,
+
+As you can see I am the maintainer of this documentation
+and have the rights to edit it ^^
+
+With best regards
+
+BennoDev

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

@@ -165,6 +165,39 @@ export interface CreateCollectionConfigInterface<DataType = DefaultItem> {
 }
 ```
 
+### `groups`
+Here we define the initial [Groups](#groups) of our Collection.
+We have two options to add them. 
+The first way is to just pass an Array of Group Names, than
+AgileTs creates these Groups for us.
+```ts
+const MY_COLLECTION = App.createCollection({
+    groups: ["myGroup1", "myGroup2"]
+});
+```
+But if we want to add some initial Items to the Groups we have to go the
+`function` config way.
+```ts
+const MY_COLLECTION = App.createCollection((collection) => ({
+     key: 'dummyCollection',
+     group: {
+        myGroup1: collection.Group(["item1", "item2"]),
+        myGroup2: collection.Group(["item5", "item2", "item6"])
+      }
+     }))
+```
+
+### `key`
+The Key/Name is an optional property, that gets used to identify our Collection.
+This is pretty useful during debug sessions or if we persist our Collection,
+where it automatically uses the `key` as persist key.
+We recommend giving each Collection an unique `key`. It has only advantages.
+```ts
+const MY_COLLECTION = App.createCollection({
+    key: "myKey"
+});
+```
+
 
 ## 🟦 Typescript
 
@@ -177,4 +210,5 @@ interface UserInterface {
 const MY_COLLECTION = App.createState<UserInterface>();
 MY_COLLECTION.collect({id: "invalidType", animal: "Lion"}); // Error
 MY_COLLECTION.collect({id: 1, name: "hans"}); // Success
-```
+```
+This type defines the Value Type of the Collection Items.

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

@@ -19,7 +19,7 @@ By doing this the State gets automatically bound to the Agile Instance it was cr
 const MY_STATE = App.createState("Hello World");
 ```
 There is also a way to use the plain `State Class`,
-but there we have to pass the `Agile Instance`, to which the State should get bound, beside the initial Value and config.
+but there we have to pass the `Agile Instance`, to which the State should get bound, beside the initial Value.
 ```ts
 const MY_STATE = new State(App, "Hello World");
 ```
@@ -38,7 +38,7 @@ MY_STATE.undo().set("Hello Hell").watch(() => {}).reset().invert().persist().typ
 
 ## 📭 Props
 
-`State` takes, beside the initial value an optional configuration object.
+A `State` takes, beside the initial value an optional configuration object.
 ```ts
 const MY_STATE = App.createState("myInitialValue", {
     key: "myKey",
@@ -56,8 +56,8 @@ export interface StateConfigInterface {
 ```
 
 ### `key`
-The Key/Name is an optional property, that gets used to identify a State.
-This is pretty useful during debug sessions or if we persist a State,
+The Key/Name is an optional property, that gets used to identify our State.
+This is pretty useful during debug sessions or if we persist our State,
 where it automatically uses the `key` as persist key.
 We recommend giving each State an unique `key`. It as only advantages.
 ```ts
@@ -74,9 +74,9 @@ Gets mostly used internal and has properly no use for you.
 
 :::
 
-`Dependents` is used to detect States, that depend on this State.
+Here we define which States depend on our State.
 This means if our State gets mutated and ingested into the Runtime,
-the depending State gets also ingested into the Runtime.
+the depending States gets also ingested into the Runtime.
 ```ts
 const MY_STATE = App.createState("myInitialValue", {
     dependents: [MY_STATE_2]
@@ -91,8 +91,8 @@ Gets mostly used internal and has properly no use for you.
 
 :::
 
-With `isPlaceholder` we define, that this State is a placeholder.
-Mostly a State is a Placeholder if we want to hold a reference to a State that hasn't been instantiated yet.
+With `isPlaceholder` we define, that our State is a placeholder.
+Mostly a State is a Placeholder if we want to hold a reference to it, because hasn't been instantiated yet.
 ```ts
 const MY_STATE = App.createState("myInitialValue", {
     isPlaceholder: true
@@ -112,4 +112,4 @@ Javascript users can also get rudimentary typesafe, with the `type` function.
 ```ts
 MY_STATE.type(String); // Now State only accept State Values
 ```
-Be aware that the `type` function currently only supports primitive types.
+Be aware that the `type` function currently only supports primitive types.