fixed typos

Author: bennobuilder

docs/Interfaces.md

@@ -102,7 +102,7 @@ During the overwrite process, the following properties are overwritten:
 
 Whether to apply the State value changes to the corresponding external [Storage/s](packages/core/api/storage/Introduction.md).
 ```ts {1}
-const MY_STATE = App.creacteState('jeff').persist('storageKey');
+const MY_STATE = createState('jeff').persist('storageKey');
 // Storage at 'storageKey': 'jeff'
 MY_STATE.set("hans", {storage: true});
 // Storage at 'storageKey': 'hans'
@@ -463,7 +463,7 @@ We recommend giving each Selector a unique `key` since it has only advantages:
 
 Defines whether the Selector is a `placeholder`.
 ```ts
-const MY_SELECTOR = App.creaateSelector(1, {
+const MY_SELECTOR = MY_COLLECTION.createSelector(1, {
     isPlaceholder: true
 });
 

docs/main/Introduction.md

@@ -21,6 +21,13 @@ slug: /introduction/
 <br />
 <br />
 
+:::info
+
+Want to get a quick overview of AgileTs?
+Checkout the [AgileTs Introduction Blogpost](https://dev.to/bennodev19/createstate-introducing-agilets-a-flexible-state-manager-91f).
+
+:::
+
 ## 👋 Introduction {#introduction}
 
 AgileTs is a global State and Logic Library implemented in Typescript.

docs/main/StyleGuides.md

@@ -37,8 +37,8 @@ Feel free to choose one of them and adapt it to your needs.
 ## 🚀 Inspiration 1
 
 The `Style Guide 1` is intended for **smaller and medium size applications** 
-with about `1-3` entities. In AgileTs, `entities` are things with distinct 
-and independent existence like users, posts, or todos.
+with about `1-3` entities. (In AgileTs, `entities` are things with distinct 
+and independent existence like users, posts, or todos.)
 We put everything related to these entities 
 into a single file of truth called `store.js` or `core.js`.
 In the end, the `core` file contains all the business logic of your application,
@@ -72,21 +72,20 @@ how it can be constructed.
 
 ### 📝 store.ts
 
-In the `store.ts` file, we instantiate the Agile Instance (`Agile`) 
-and define all [Agile Sub Instances](../main/Introduction.md#agile-sub-instance) (`MY_TODOS`).
-In addition, all actions (`updateTodo()`, `toogleTodo()`, ..) 
-and if you are using Typescript interfaces (`TodoInterface`) are located here.
+In the `store.ts` file, we instantiate all [Agile Sub Instances](../main/Introduction.md#agile-sub-instance) (`MY_TODOS`),
+define all actions (`updateTodo()`, `toogleTodo()`, ..) 
+and if you are using Typescript interfaces (`TodoInterface`) are located here too.
 ```ts title="store.ts"
 import { createCollection } from "@agile-ts/core";
 
-export interface TodoInterface {
+export interface TodoItemInterface {
   id: number;
   text: string;
   done: boolean;
 }
 
 // Create Collection (a dynamic set of States)
-export const MY_TODOS = createCollection<TodoInterface>({
+export const MY_TODOS = createCollection<TodoItemInterface>({
   key: "todos"
 }).persist(); // perist does store the Collection in the Local Storage
 
@@ -134,7 +133,7 @@ We can easily differentiate between global and local States in our UI-Components
 
 The `Style Guide 2` is intended for **medium size and large applications** 
 with more than `3` entities. 
-In AgileTs, `entities` are things with distinct and independent existence like users, posts, or todos.
+(In AgileTs, `entities` are things with distinct and independent existence like users, posts, or todos.)
 At first glance, this way of organizing your application looks very boiler-late-ey. 
 Each entity has its own directory with a bunch of files.
 However, there is a system behind it,
@@ -190,7 +189,6 @@ core
 |       └── user.controller.ts
 |       └── user.interfaces.ts
 |       └── user.routes.ts
-|── app.ts
 |── index.ts
 .
 ```
@@ -373,33 +371,6 @@ export const ADD_TODO = async (payload: AddTodoPayloadInterface): Promise<TodoIn
 // ..
 ```
 
-## 📝 app.ts
-
-:::note
-
-If you decided to use the 
-[shared Agile Instance](../packages/core/api/agile-instance/Introduction.md#-shared-agile-instance) 
-you can skip this part.
-
-:::
-
-In the `app.ts` file, we create our main `Agile Instance` and configure it to meet our needs.
-For example, we determine here with which UI-Framework AgileTs should work together.
-
-```ts title="app.ts"
-import {Agile, Logger, assignSharedAgileInstance} from "@agile-ts/core";
-import reactIntegration from "@agile-ts/react";
-
-export const App = new Agile({
-    logConfig: {
-        level: Logger.level.WARN
-    }
-}).integrate(reactIntegration);
-
-// Assign created Agile Instance as shared Agile Instance
-assignSharedAgileInstance(App);
-```
-
 ## 📝 index.ts
 
 Here we export our `core` entities, so that each entity 

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

@@ -46,7 +46,7 @@ In summary the main tasks of the `Agile Class` are to:
 
 ## 🤝 `shared` Agile Instance
 
-In most cases you won't come in direct contact with the hidden helper (Agile Instance), 
+In most cases you won't come in direct contact with this hidden helper (Agile Instance), 
 although everything depends on it.
 That is due the fact that there exists a shared Agile Instance called `shared` in the background.
 The shared Instance allows the easy and straightforward creation of [ASI's](../../../../main/Introduction.md#agile-sub-instance), 
@@ -64,14 +64,20 @@ you have to redefine it.
 ```ts
 const App = new Agile({/* many config options */});
 ```
-Once you have created your own Agile Instance,
-we recommend that you overwrite the `shared` Agile Instance
+Once you have created your customized Agile Instance,
+we recommend overwriting the `shared` Agile Instance
 with the newly created Agile Instance.
 ```ts
 assignSharedAgileInstance(App);
 ```
 Otherwise, there would exist two instances of Agile 
 which is an unnecessary use of memory.
+Also, is the straightforward creation of States based on the shared Agile Instance.
+```ts
+createState('jeff'); // Uses the shared Agile Instance
+createState('jeff', {agileInstance: App}); // Uses the specified Agile Instance
+```
+
 
 ## 📭 Props
 
@@ -84,20 +90,18 @@ new Agile(config);
 The `Agile Class` takes an optional configuration object as its only parameter.
 ```ts
 new Agile({
-    logConfig: {
-        active: true,
-    },
-    localStorage: false
+  key: 'main',
+  bindGlobal: true
 });
 ```
 Here is a Typescript Interface for quick reference. However,
 each property is explained in more detail below.
 ```ts
 export interface CreateAgileConfigInterface {
-  logConfig?: CreateLoggerConfigInterface;
-  localStorage?: boolean;
   waitForMount?: boolean;
   bindGlobal?: boolean;
+  key?: AgileKey;
+  bucket?: boolean;
 }
 ```
 
@@ -116,47 +120,53 @@ new Agile({
 <br/>
 
 #### `logConfig`
-
 :::warning
 
-The `loggerConfig` configuration option has been deprecated in the latest version `^0.1.1`
+The `loggerConfig` configuration option has been deprecated in the latest versions `^0.1.1`
 and is no longer available!
 
+### Why?
+Optimizing `bundle size`.
+
+### Alternative?
 Now, `warnings` and `errors` are logged in general.
 However, to configure the logging behavior of AgileTs more precisely
 an external package [`@agile-ts/logger`](../../../logger/Introduction.md) is required.
-
 ```ts
-import {Logger, assignSharedAgileLoggerConfig} from '@agile-ts/logger';
+import {assignSharedLogger, createLogger, Logger} from '@agile-ts/logger';
 
-assignSharedAgileLoggerConfig({
-    logConfig: {
-        level: Logger.level.DEBUG,
-        active: true,
-        timestamp: true
-    } 
-});
+assignSharedLogger(createLogger({
+  level: Logger.level.DEBUG,
+  active: true,
+  timestamp: true
+}));
 ```
 
 :::
 
 <br/>
 
 #### `localStorage`
-Whether AgileTs should create an interface to the [Local Storage](https://www.w3schools.com/html/html5_webstorage.asp) and set it as default Storage.
-Each [Agile Sub Instance](../../../../main/Introduction.md#agile-sub-instance) we persist (`.persist()`), will then be stored in the `localStorage` by default.
+:::warning
+
+The `localStorage` configuration option has been deprecated in the latest versions `^0.2.0`
+and is no longer available!
+
+### Why?
+Optimizing `tree shaking` support.
+
+### Alternative?
+Now, the local storage is added by default.
+However, to configure this behavior, 
+we need to assign a custom shared [`Storage Manger`](../storage/Introduction.md).
 ```ts
-new Agile({
-  localStorage: false // default true
-});
+import {createStorageManager, assignSharedStorageManager} from "@agile-ts/core";
+
+const storageManager = createStorageManager({ localStorage: false });
+assignSharedStorageManager(storageManager);
 ```
-We aren't limited to the `localStorage` and can create Interfaces to nearly any [Storage](../storage/Introduction.md) we prefer saving data in.
-For instance, that is necessary for a Mobile Environment since the `localStorage` doesn't exist, and we have to resort to the Async Storage.
-With `App.registerStorage()` we register a new [Storage](../storage/Introduction.md) to AgileTs.
 
-| Type            | Default     | Required |
-|-----------------|-------------|----------|
-| `boolean`       | true        | No       |
+:::
 
 <br/>