removed App.x

Author: bennobuilder

docs/Interfaces.md

@@ -188,7 +188,7 @@ or _updating the persisted State value in the corresponding external Storage_.
 
 When set to `true`, the Job is forced through the `runtime` no matter what happens.
 ```ts {7}
-const MY_STATE = App.createState('myValue');
+const MY_STATE = createState('myValue');
 
 // Won't be executed by the runtime because the State value hasn't changed
 MY_STATE.set('myValue');
@@ -275,7 +275,7 @@ export interface PatchConfigInterface extends StateIngestConfigInterface {
 
 If `true`, new properties are added to the State value, although they might not yet be present there.
 ```ts {2,4}
-const MY_STATE = App.createState({id: 1, name: "frank"});
+const MY_STATE = createState({id: 1, name: "frank"});
 MY_STATE.patch({location: "Germany"}, {addNewProperties: false}); 
 MY_STATE.value; // Returns {id: 1, name: "frank"}
 MY_STATE.patch({location: "Germany"}, {addNewProperties: true});
@@ -395,7 +395,7 @@ We recommend giving each Group a unique `key` since it has only advantages:
 
 Defines whether the Group is a `placeholder`.
 ```ts
-const MY_GROUP = App.createGroup([1, 2, 3], {
+const MY_GROUP = createGroup([1, 2, 3], {
     isPlaceholder: true
 });
 
@@ -522,7 +522,7 @@ if we collect a data object with an already existing `primaryKey` in order to up
 
 If `true`, the passed data object is merged into the found Item data instead of overwriting it entirely.
 ```ts {6,9}
-const MY_COLLECTION = App.createCollection({
+const MY_COLLECTION = createCollection({
     initialData: [{id: 1, name: 'frank', age: 10}]
 });
 

docs/main/StyleGuides.md

@@ -77,20 +77,16 @@ and define all [Agile Sub Instances](../main/Introduction.md#agile-sub-instance)
 In addition, all actions (`updateTodo()`, `toogleTodo()`, ..) 
 and if you are using Typescript interfaces (`TodoInterface`) are located here.
 ```ts title="store.ts"
-import { Agile, assignSharedAgileInstance } from "@agile-ts/core";
-import reactIntegration from "@agile-ts/react";
+import { createCollection } from "@agile-ts/core";
 
 export interface TodoInterface {
   id: number;
   text: string;
   done: boolean;
 }
 
-// Create Agile Instance
-const App = new Agile().integrate(reactIntegration);
-
 // Create Collection (a dynamic set of States)
-export const MY_TODOS = App.createCollection<TodoInterface>({
+export const MY_TODOS = createCollection<TodoInterface>({
   key: "todos"
 }).persist(); // perist does store the Collection in the Local Storage
 
@@ -309,15 +305,15 @@ and contains the [Agile Sub Instances](../main/Introduction.md#agile-sub-instanc
 These Agile Sub Instances can and should then only be modified by the actions ([actions.ts](#1-actionsts))
 or bound to UI-Components in the UI-Layer for reactivity.
 ```ts title="todo.controller.ts in 📁todo"
-import {App} from '../../app';
+import {createCollection, createComputed} from "@agile-ts/core";
 import {TodoInterface} from './todo.interfaces';
 import {CURRENT_USER} from '../user'
 
 // Contains all existing TODO's
-export const TODOS = App.createCollection<TodoInterface>()();
+export const TODOS = createCollection<TodoInterface>()();
 
 // Contains all TODO's that belong to the current logged in USER
-export const USER_TODOS = App.createComputed(() => {
+export const USER_TODOS = createComputed(() => {
     return TodosCollection.getGroup(CURRENT_USER.value.id).output;
 });
 ```

docs/packages/core/Introduction.md

@@ -44,7 +44,7 @@ which includes, for example, handy classes like:
   that we need to remember globally at a later point in time.
   While offering a toolkit to use and mutate this _set_ of Information.
   ```ts
-  const MY_COLLECTION = App.createCollection();
+  const MY_COLLECTION = createCollection();
 
   // Add Data to Collection
   MY_COLLECTION.collect({id: 1, name: "frank"});
@@ -57,7 +57,7 @@ which includes, for example, handy classes like:
   A `Computed` is an extension of the `State Class` that computes
   its value from a specified function.
   ```ts
-   const MY_COMPUTED = App.createComputed(() => {
+   const MY_COMPUTED = createComputed(() => {
      return MY_STATE_1.value + MY_STATE_2.value;
   });
   ```

docs/packages/core/api/agile-instance/Introduction.md

@@ -19,21 +19,21 @@ created with an instantiated `Agile Instance` called `App`:
 
 - [State](../state/Introduction.md)
   ```ts
-   const MY_STATE = new State(App, "Hello there");
+   const MY_STATE = new State(sharedAgileInstance, "Hello there");
    // equals to
-   const MY_STATE = App.createState("Hello there");
+   const MY_STATE = createState("Hello there");
    ```
 - [Collection](../collection/Introduction.md)
    ```ts
-   const MY_COLLECTION = new Collection(App);
+   const MY_COLLECTION = new Collection(sharedAgileInstance);
    // equals to
-   const MY_COLLECTION = App.createCollection();
+   const MY_COLLECTION = createCollection();
    ```
 - [Computed](../computed/Introduction.md)
    ```ts
-   const MY_COMPUTED = new Computed(App, () => 'hello');
+   const MY_COMPUTED = new Computed(sharedAgileInstance, () => 'hello');
    // equals to
-   const MY_COMPUTED = App.createComputed(() => 'hello');
+   const MY_COMPUTED = createComputed(() => 'hello');
    ```
 
 In summary the main tasks of the `Agile Class` are to:

docs/packages/core/api/agile-instance/Methods.md

@@ -32,7 +32,7 @@ createState('jeff', App);
 Creates a new [State](../state/Introduction.md),
 which is automatically bound to the [Agile Instance](../agile-instance/Introduction.md) it was created from.
 ```ts
-const State = App.createState('jeff', {
+const State = createState('jeff', {
     key: 'dummyState',
 })
 ```
@@ -80,14 +80,14 @@ createCollection({}, App);
 Creates a new [Collection](../collection/Introduction.md),
 which is automatically bound to the [Agile Instance](../agile-instance/Introduction.md) it was created from.
 ```ts {1-4,8-13}
-const Collection = App.createCollection({
+const Collection = createCollection({
     key: 'dummyCollection',
     groups: ['myGroup']
 })
 
 // or 
 
-const Collection2 = App.createCollection((collection) => ({
+const Collection2 = createCollection((collection) => ({
     key: 'dummyCollection',
     groups: {
         myGroup: collection.Group(['item1', 'item2'])
@@ -138,11 +138,11 @@ createComputed(() => {}, {agileInstance: App});
 Creates a new [Computed](../computed/Introduction.md),
 which is automatically bound to the [Agile Instance](../agile-instance/Introduction.md) it was created from.
 ```ts {1,5-7}
-const Computed = App.createComputed(() => {/* Computed Method */}, [/* hard coded deps */])
+const Computed = createComputed(() => {/* Computed Method */}, [/* hard coded deps */])
 
 // or
 
-const ComputedWithConfig = App.createComputed(() => {/* Computed Method */}, {
+const ComputedWithConfig = createComputed(() => {/* Computed Method */}, {
     key: 'dummyComputed',
 }, [/* hard coded deps */])
 ```
@@ -245,7 +245,7 @@ createStorage({/* config */});
 Creates a new [Storage](../storage/Introduction.md) Interface for AgileTs.
 Such Storage Interface allows AgileTs to easily work with the Storage the Interface represents hand in hand.
 ```ts
-const Storage = App.createStorage({
+const Storage = createStorage({
     key: 'dummyStorage',
     methods: {
         get: (key: string) => {},
@@ -288,7 +288,7 @@ The [Local Storage](https://developer.mozilla.org/de/docs/Web/API/Window/localSt
 Below you can see how the Local Storage is registered internally, if the `localStorage` flag got set.
 ```ts {13}
 // create localStorage Interface with help of the Agile Storage
-const _localStorage = App.createStorage({
+const _localStorage = createStorage({
     key: 'localStorage',
     async: false,
     methods: {

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

@@ -51,7 +51,7 @@ MY_COLLECTION.collect({id: 1, name: "jeff"}).persist().removeGroup('myGroup').re
 ### 🔨 Use case
 We might use a Collection to remember a flexible and reactive array of todo objects.
 ```ts
-const TODOS = App.createCollection();
+const TODOS = createCollection();
 // <- add todos
 TODOS.collect({id: 1, todo: "Clean bathroom"}, ["user1"]);
 TODOS.collect({id: 2, todo: "Write Agile docs"},  ["user1"]);
@@ -173,8 +173,6 @@ console.log(MY_SELECTOR.value); // Returns '{id: 'id0', name: 'jeff'}'
 
 ```ts
 new Collection(agileInstance, config);
-// or
-App.createCollection(config);
 // or 
 createCollection(config);
 ```
@@ -189,7 +187,7 @@ There are two different ways of configuring a Collection. Both have their advant
   But on the other hand, it gives us some limitations, since we aren't creating and configuring the Groups and Selectors on our own.
   The Collection takes care of it instead.
      ```ts
-     App.createCollection({
+     createCollection({
        key: 'dummyCollection',
        group: ["dummyGroup"]
      })
@@ -199,7 +197,7 @@ There are two different ways of configuring a Collection. Both have their advant
   This gives us more freedom in configuring Instances like Groups,
   because we have access to the Collection and can create them on our own.
      ```ts
-     App.createCollection((collection) => ({
+     createCollection((collection) => ({
        key: 'dummyCollection',
        group: {
           dummyGroup: collection.Group(["item1", "item2"])
@@ -228,15 +226,15 @@ There are two different ways of doing so.
 The first one is to pass an Array of Group keys/names,
 where AgileTs takes care of the Group's creation and names them according to the passed keys.
 ```ts
-App.createCollection({
+createCollection({
   groups: ["myGroup1", "myGroup2"]
 });
 ```
 The way mentioned above has some limitations, since we can't configure the Groups ourselves.
 Fortunately, there is a second way where we have access to the Collection itself,
 and can define and configure the Groups on our own.
 ```ts
-App.createCollection((collection) => ({
+createCollection((collection) => ({
   key: 'dummyCollection',
   group: {
     myGroup1: collection.Group(["item1", "item2"], {/* some configuration */}),
@@ -257,15 +255,15 @@ As with the `groups` property, there are two different ways of doing so.
 The first one is to pass an Array of Selector keys/names,
 where AgileTs takes care of the Selector's creation and names them according to the passed keys.
 ```ts
-App.createCollection({
+createCollection({
   selectors: ["mySelector1", "mySelector2"]
 });
 ```
 The way mentioned above has some limitations, since we can't configure the Selectors ourselves.
 Fortunately, there is a second way where we have access to the Collection itself,
 and can define and configure the Selectors on our own.
 ```ts
-App.createCollection((collection) => ({
+createCollection((collection) => ({
   key: 'dummyCollection',
   selectors: {
     mySelector1: collection.Selector("item1", {/* some configuration */}),
@@ -283,7 +281,7 @@ App.createCollection((collection) => ({
 #### `key`
 The optional property `key/name` should be a unique `string/number` to identify the Collection later.
 ```ts
-App.createCollection({
+createCollection({
   key: "myKey"
 });
 ```
@@ -302,7 +300,7 @@ We recommend giving each Collection a unique `key`, since it has only advantages
 Defines which property's value in collected data is selected as `primaryKey`.
 By default, it is `id`. A `primaryKey` identifies a specific Item and has to be part of each collected data.
 ```ts
-const MY_COLLECTION = App.createCollection({
+const MY_COLLECTION = createCollection({
   primaryKey: "key"
 });
 MY_COLLECTION.collect({key: 1, name: "hans"});
@@ -321,7 +319,7 @@ MY_COLLECTION.collect({key: 1, name: "hans"});
 Describes the `key/name` of the default [Group](#-groupgroupintroductionmd).
 By default, it is `default`.
 ```ts
-App.createCollection({
+createCollection({
   defaultGroupKey: "allItemsOfCollectionKey"
 });
 ```
@@ -336,7 +334,7 @@ The default Group represents all Items of the Collection.
 #### `initialData`
 Here we can set the initial Data of our Collection.
 ```ts
-App.createCollection({
+createCollection({
   initialData: [{id: 1, name: "hans"}, {id: 2, name: "frank"}]
 });
 ```
@@ -356,7 +354,7 @@ interface UserInterface {
   name: string
 }
 
-const MY_COLLECTION = App.createState<UserInterface>();
+const MY_COLLECTION = createState<UserInterface>();
 MY_COLLECTION.collect({id: "invalidType", animal: "Lion"}); // type Error
 MY_COLLECTION.collect({id: 1, name: "hans"}); // Success
 ```

docs/packages/core/api/collection/Methods.md

@@ -53,7 +53,7 @@ Creates a new [Group](./group/Introduction.md) without associating it to the Col
 Therefore, this function is intended for use in the Collection `config` object,
 where the `constructor()` takes care of the associating.
 ```ts {3}
-App.createCollection((collection) => ({
+createCollection((collection) => ({
   groups: {
     myGroup: collection.Group(["item1", "item2"])
   }
@@ -65,13 +65,13 @@ collection.Group(["item1", "item2"]);
 ```
 The object key is used as `groupKey`, if we don't pass a separate key into the Group `config`.
 ```ts {3,9}
-App.createCollection((collection) => ({
+createCollection((collection) => ({
     groups: {
         myGroup: collection.Group(["item1", "item2"], {key: "myCoolGroup"}) // Key === "myCoolGroup"
     }
 }));
 
-App.createCollection((collection) => ({
+createCollection((collection) => ({
     groups: {
         myGroup: collection.Group(["item1", "item2"]) // Key === "myGroup"
     }
@@ -112,7 +112,7 @@ Creates a new [Selector](./selector/Introduction.md) without associating it to t
 Therefore, this function is intended for use in the Collection `config` object,
 where the `constructor()` takes care of the associating.
 ```ts {3}
-App.createCollection((collection) => ({
+createCollection((collection) => ({
     selectors: {
         mySelector: collection.Selector("item1")
     }
@@ -124,13 +124,13 @@ collection.Selector("item1");
 ```
 The object key is used as `selectorKey`, if we don't pass a separate key into the Selector `config`.
 ```ts {3,9}
-App.createCollection((collection) => ({
+createCollection((collection) => ({
     selectors: {
         mySelector: collection.Selector("item1", {key: "myCoolSelector"}) // Key === "myCoolSelector"
     }
 }));
 
-App.createCollection((collection) => ({
+createCollection((collection) => ({
     selectors: {
         mySelector: collection.Selector("item1") // Key === "mySelector"
     }

docs/packages/core/api/collection/Properties.md

@@ -41,7 +41,7 @@ Agile
 The current `key/name` of the Collection,
 which is used for a unique identification.
 ```ts {2}
-const MY_COLLECTION = App.createCollection({key: 'jeffKey'});
+const MY_COLLECTION = createCollection({key: 'jeffKey'});
 MY_COLLECTION.key; // Returns 'jeffKey'
 ```
 Besides accessing the `key`, we can also assign a new `key` using this property.
@@ -220,4 +220,4 @@ MY_COLLECTION.selectors[1]; // Bad pattern
 
 ```ts
 { [key: string]: Selector<DataType> }
-```
+```