@push.rocks/smartstate 2.0.6

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartstate',
+    version: '2.0.6',
+    description: 'a package that handles state in a good way'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDRDQUE0QztDQUMxRCxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './smartstate.classes.smartstate.js';
+export * from './smartstate.classes.statepart.js';
+export * from './smartstate.classes.stateaction.js';

package/dist_ts/index.js

@@ -0,0 +1,4 @@
+export * from './smartstate.classes.smartstate.js';
+export * from './smartstate.classes.statepart.js';
+export * from './smartstate.classes.stateaction.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxxQ0FBcUMsQ0FBQyJ9

package/dist_ts/smartstate.classes.smartstate.d.ts

@@ -0,0 +1,26 @@
+import { StatePart } from './smartstate.classes.statepart.js';
+/**
+ * Smartstate takes care of providing state
+ */
+export declare class Smartstate<StatePartNameType> {
+    statePartMap: {
+        [key: string]: StatePart<StatePartNameType, any>;
+    };
+    constructor();
+    /**
+     * Allows getting and initializing a new statepart
+     * initMode === 'soft' it will allow existing stateparts
+     * initMode === 'mandatory' will fail if there is an exiting statepart
+     * initMode === 'force' will overwrite any existing statepart
+     * @param statePartNameArg
+     * @param initialArg
+     * @param initMode
+     */
+    getStatePart<PayloadType>(statePartNameArg: string & StatePartNameType, initialArg?: PayloadType, initMode?: 'soft' | 'mandatory' | 'force'): StatePart<StatePartNameType, PayloadType>;
+    /**
+     * creates a statepart
+     * @param statePartName
+     * @param initialPayloadArg
+     */
+    private createStatePart;
+}

package/dist_ts/smartstate.classes.smartstate.js

@@ -0,0 +1,45 @@
+import './smartstate.plugins.js';
+import { StatePart } from './smartstate.classes.statepart.js';
+/**
+ * Smartstate takes care of providing state
+ */
+export class Smartstate {
+    constructor() {
+        this.statePartMap = {};
+    }
+    /**
+     * Allows getting and initializing a new statepart
+     * initMode === 'soft' it will allow existing stateparts
+     * initMode === 'mandatory' will fail if there is an exiting statepart
+     * initMode === 'force' will overwrite any existing statepart
+     * @param statePartNameArg
+     * @param initialArg
+     * @param initMode
+     */
+    getStatePart(statePartNameArg, initialArg, initMode) {
+        if (this.statePartMap[statePartNameArg]) {
+            if (initialArg && (!initMode || initMode !== 'soft')) {
+                throw new Error(`${statePartNameArg} already exists, yet you try to set an initial state again`);
+            }
+            return this.statePartMap[statePartNameArg];
+        }
+        else {
+            if (!initialArg) {
+                throw new Error(`${statePartNameArg} does not yet exist, yet you don't provide an initial state`);
+            }
+            return this.createStatePart(statePartNameArg, initialArg);
+        }
+    }
+    /**
+     * creates a statepart
+     * @param statePartName
+     * @param initialPayloadArg
+     */
+    createStatePart(statePartName, initialPayloadArg) {
+        const newState = new StatePart(statePartName);
+        newState.setState(initialPayloadArg);
+        this.statePartMap[statePartName] = newState;
+        return newState;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdGF0ZS5jbGFzc2VzLnNtYXJ0c3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHN0YXRlLmNsYXNzZXMuc21hcnRzdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUF5Qix5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFOUQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sVUFBVTtJQUdyQjtRQUZPLGlCQUFZLEdBQXlELEVBQUUsQ0FBQztJQUVoRSxDQUFDO0lBRWhCOzs7Ozs7OztPQVFHO0lBQ0ksWUFBWSxDQUNqQixnQkFBNEMsRUFDNUMsVUFBd0IsRUFDeEIsUUFBeUM7UUFFekMsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDLGdCQUF1QixDQUFDLEVBQUU7WUFDOUMsSUFBSSxVQUFVLElBQUksQ0FBQyxDQUFDLFFBQVEsSUFBSSxRQUFRLEtBQUssTUFBTSxDQUFDLEVBQUU7Z0JBQ3BELE1BQU0sSUFBSSxLQUFLLENBQ2IsR0FBRyxnQkFBZ0IsNERBQTRELENBQ2hGLENBQUM7YUFDSDtZQUNELE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBOEMsQ0FBQztTQUN6RjthQUFNO1lBQ0wsSUFBSSxDQUFDLFVBQVUsRUFBRTtnQkFDZixNQUFNLElBQUksS0FBSyxDQUNiLEdBQUcsZ0JBQWdCLDZEQUE2RCxDQUNqRixDQUFDO2FBQ0g7WUFDRCxPQUFPLElBQUksQ0FBQyxlQUFlLENBQWMsZ0JBQWdCLEVBQUUsVUFBVSxDQUFDLENBQUM7U0FDeEU7SUFDSCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNLLGVBQWUsQ0FDckIsYUFBZ0MsRUFDaEMsaUJBQThCO1FBRTlCLE1BQU0sUUFBUSxHQUFHLElBQUksU0FBUyxDQUFpQyxhQUFhLENBQUMsQ0FBQztRQUM5RSxRQUFRLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUM7UUFDckMsSUFBSSxDQUFDLFlBQVksQ0FBQyxhQUFvQixDQUFDLEdBQUcsUUFBUSxDQUFDO1FBQ25ELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

package/dist_ts/smartstate.classes.stateaction.d.ts

@@ -0,0 +1,13 @@
+import { StatePart } from './smartstate.classes.statepart.js';
+export interface IActionDef<TStateType, TActionPayloadType> {
+    (stateArg: StatePart<any, TStateType>, actionPayload: TActionPayloadType): Promise<TStateType>;
+}
+/**
+ * an actionmodifier for the state
+ */
+export declare class StateAction<TStateType, TActionPayloadType> {
+    statePartRef: StatePart<any, any>;
+    actionDef: IActionDef<TStateType, TActionPayloadType>;
+    constructor(statePartRef: StatePart<any, any>, actionDef: IActionDef<TStateType, TActionPayloadType>);
+    trigger(payload: TActionPayloadType): void;
+}

package/dist_ts/smartstate.classes.stateaction.js

@@ -0,0 +1,15 @@
+import './smartstate.plugins.js';
+import './smartstate.classes.statepart.js';
+/**
+ * an actionmodifier for the state
+ */
+export class StateAction {
+    constructor(statePartRef, actionDef) {
+        this.statePartRef = statePartRef;
+        this.actionDef = actionDef;
+    }
+    trigger(payload) {
+        this.statePartRef.dispatchAction(this, payload);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdGF0ZS5jbGFzc2VzLnN0YXRlYWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzdGF0ZS5jbGFzc2VzLnN0YXRlYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQXlCLHlCQUF5QixDQUFDO0FBQ25ELE9BQTBCLG1DQUFtQyxDQUFDO0FBTTlEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFdBQVc7SUFDdEIsWUFDUyxZQUFpQyxFQUNqQyxTQUFxRDtRQURyRCxpQkFBWSxHQUFaLFlBQVksQ0FBcUI7UUFDakMsY0FBUyxHQUFULFNBQVMsQ0FBNEM7SUFDM0QsQ0FBQztJQUVHLE9BQU8sQ0FBQyxPQUEyQjtRQUN4QyxJQUFJLENBQUMsWUFBWSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDbEQsQ0FBQztDQUNGIn0=

package/dist_ts/smartstate.classes.statepart.d.ts

@@ -0,0 +1,48 @@
+import * as plugins from './smartstate.plugins.js';
+import { StateAction, IActionDef } from './smartstate.classes.stateaction.js';
+export declare class StatePart<TStatePartName, TStatePayload> {
+    name: TStatePartName;
+    state: plugins.smartrx.rxjs.Subject<TStatePayload>;
+    stateStore: TStatePayload;
+    private cumulativeDeferred;
+    constructor(nameArg: TStatePartName);
+    /**
+     * gets the state from the state store
+     */
+    getState(): TStatePayload;
+    /**
+     * sets the stateStore to the new state
+     * @param newStateArg
+     */
+    setState(newStateArg: TStatePayload): void;
+    /**
+     * notifies of a change on the state
+     */
+    notifyChange(): void;
+    private lastStateNotificationPayloadHash;
+    /**
+     * creates a cumulative notification by adding a change notification at the end of the call stack;
+     */
+    notifyChangeCumulative(): void;
+    /**
+     * selects a state or a substate
+     */
+    select<T = TStatePayload>(selectorFn?: (state: TStatePayload) => T): plugins.smartrx.rxjs.Observable<T>;
+    /**
+     * creates an action capable of modifying the state
+     */
+    createAction<TActionPayload>(actionDef: IActionDef<TStatePayload, TActionPayload>): StateAction<TStatePayload, TActionPayload>;
+    /**
+     * dispatches an action on the statepart level
+     */
+    dispatchAction<T>(stateAction: StateAction<TStatePayload, T>, actionPayload: T): Promise<void>;
+    /**
+     * waits until a certain part of the state becomes available
+     * @param selectorFn
+     */
+    waitUntilPresent<T = TStatePayload>(selectorFn?: (state: TStatePayload) => T): Promise<T>;
+    /**
+     * is executed
+     */
+    stateSetup(funcArg: (statePartArg?: StatePart<any, TStatePayload>) => Promise<TStatePayload>): Promise<void>;
+}

package/dist_ts/smartstate.classes.statepart.js

@@ -0,0 +1,103 @@
+import * as plugins from './smartstate.plugins.js';
+import { StateAction } from './smartstate.classes.stateaction.js';
+export class StatePart {
+    constructor(nameArg) {
+        this.state = new plugins.smartrx.rxjs.Subject();
+        this.cumulativeDeferred = plugins.smartpromise.cumulativeDefer();
+        this.name = nameArg;
+    }
+    /**
+     * gets the state from the state store
+     */
+    getState() {
+        return this.stateStore;
+    }
+    /**
+     * sets the stateStore to the new state
+     * @param newStateArg
+     */
+    setState(newStateArg) {
+        this.stateStore = newStateArg;
+        this.notifyChange();
+    }
+    /**
+     * notifies of a change on the state
+     */
+    notifyChange() {
+        const createStateHash = (stateArg) => {
+            return plugins.isohash.sha256FromString(plugins.smartjson.stringify(stateArg));
+        };
+        if (this.stateStore &&
+            this.lastStateNotificationPayloadHash &&
+            createStateHash(this.stateStore) === this.lastStateNotificationPayloadHash) {
+            return;
+        }
+        else {
+            this.lastStateNotificationPayloadHash = this.stateStore;
+        }
+        this.state.next(this.stateStore);
+    }
+    /**
+     * creates a cumulative notification by adding a change notification at the end of the call stack;
+     */
+    notifyChangeCumulative() {
+        // TODO: check viability
+        setTimeout(() => this.state.next(this.stateStore), 0);
+    }
+    /**
+     * selects a state or a substate
+     */
+    select(selectorFn) {
+        if (!selectorFn) {
+            selectorFn = (state) => state;
+        }
+        const mapped = this.state.pipe(plugins.smartrx.rxjs.ops.startWith(this.getState()), plugins.smartrx.rxjs.ops.map((stateArg) => {
+            try {
+                return selectorFn(stateArg);
+            }
+            catch (e) {
+                // Nothing here
+            }
+        }));
+        return mapped;
+    }
+    /**
+     * creates an action capable of modifying the state
+     */
+    createAction(actionDef) {
+        return new StateAction(this, actionDef);
+    }
+    /**
+     * dispatches an action on the statepart level
+     */
+    async dispatchAction(stateAction, actionPayload) {
+        await this.cumulativeDeferred.promise;
+        const newState = await stateAction.actionDef(this, actionPayload);
+        this.setState(newState);
+    }
+    /**
+     * waits until a certain part of the state becomes available
+     * @param selectorFn
+     */
+    async waitUntilPresent(selectorFn) {
+        const done = plugins.smartpromise.defer();
+        const selectedObservable = this.select(selectorFn);
+        const subscription = selectedObservable.subscribe(async (value) => {
+            if (value) {
+                done.resolve(value);
+            }
+        });
+        const result = await done.promise;
+        subscription.unsubscribe();
+        return result;
+    }
+    /**
+     * is executed
+     */
+    async stateSetup(funcArg) {
+        const resultPromise = funcArg(this);
+        this.cumulativeDeferred.addPromise(resultPromise);
+        this.setState(await resultPromise);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartstate.plugins.d.ts

@@ -0,0 +1,5 @@
+import * as isohash from '@pushrocks/isohash';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+export { isohash, smartjson, smartpromise, smartrx };

package/dist_ts/smartstate.plugins.js

@@ -0,0 +1,6 @@
+import * as isohash from '@pushrocks/isohash';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+export { isohash, smartjson, smartpromise, smartrx };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdGF0ZS5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzdGF0ZS5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sb0JBQW9CLENBQUM7QUFDOUMsT0FBTyxLQUFLLFNBQVMsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEtBQUssWUFBWSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxPQUFPLE1BQU0sb0JBQW9CLENBQUM7QUFFOUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxDQUFDIn0=

package/license

@@ -0,0 +1,19 @@
+Copyright (c) 2019 Task Venture Capital GmbH (hello@task.vc)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/npmextra.json

@@ -0,0 +1,17 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartstate",
+      "description": "a package that handles state in a good way",
+      "npmPackagename": "@pushrocks/smartstate",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@push.rocks/smartstate",
+  "version": "2.0.6",
+  "private": false,
+  "description": "a package that handles state in a good way",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "scripts": {
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany && tsbundle npm)",
+    "buildDocs": "tsdoc"
+  },
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.65",
+    "@gitzone/tsbundle": "^2.0.7",
+    "@gitzone/tsrun": "^1.2.39",
+    "@gitzone/tstest": "^1.0.74",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.15.11"
+  },
+  "dependencies": {
+    "@pushrocks/isohash": "^2.0.0",
+    "@pushrocks/lik": "^6.0.2",
+    "@pushrocks/smartjson": "^5.0.5",
+    "@pushrocks/smartpromise": "^4.0.0",
+    "@pushrocks/smartrx": "^3.0.0"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

package/readme.md

@@ -0,0 +1,37 @@
+# @pushrocks/smartstate
+a package that handles state in a good way
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartstate)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartstate)
+* [github.com (source mirror)](https://github.com/pushrocks/smartstate)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartstate/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartstate/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartstate/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartstate)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartstate)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartstate)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartstate)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartstate)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class intellisense.
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+## Legal
+> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartstate',
+  version: '2.0.6',
+  description: 'a package that handles state in a good way'
+}

package/ts/index.ts

@@ -0,0 +1,3 @@
+export * from './smartstate.classes.smartstate.js';
+export * from './smartstate.classes.statepart.js';
+export * from './smartstate.classes.stateaction.js';

package/ts/smartstate.classes.smartstate.ts

@@ -0,0 +1,57 @@
+import * as plugins from './smartstate.plugins.js';
+import { StatePart } from './smartstate.classes.statepart.js';
+
+/**
+ * Smartstate takes care of providing state
+ */
+export class Smartstate<StatePartNameType> {
+  public statePartMap: { [key: string]: StatePart<StatePartNameType, any> } = {};
+
+  constructor() {}
+
+  /**
+   * Allows getting and initializing a new statepart
+   * initMode === 'soft' it will allow existing stateparts
+   * initMode === 'mandatory' will fail if there is an exiting statepart
+   * initMode === 'force' will overwrite any existing statepart
+   * @param statePartNameArg
+   * @param initialArg
+   * @param initMode
+   */
+  public getStatePart<PayloadType>(
+    statePartNameArg: string & StatePartNameType,
+    initialArg?: PayloadType,
+    initMode?: 'soft' | 'mandatory' | 'force'
+  ): StatePart<StatePartNameType, PayloadType> {
+    if (this.statePartMap[statePartNameArg as any]) {
+      if (initialArg && (!initMode || initMode !== 'soft')) {
+        throw new Error(
+          `${statePartNameArg} already exists, yet you try to set an initial state again`
+        );
+      }
+      return this.statePartMap[statePartNameArg] as StatePart<StatePartNameType, PayloadType>;
+    } else {
+      if (!initialArg) {
+        throw new Error(
+          `${statePartNameArg} does not yet exist, yet you don't provide an initial state`
+        );
+      }
+      return this.createStatePart<PayloadType>(statePartNameArg, initialArg);
+    }
+  }
+
+  /**
+   * creates a statepart
+   * @param statePartName
+   * @param initialPayloadArg
+   */
+  private createStatePart<PayloadType>(
+    statePartName: StatePartNameType,
+    initialPayloadArg: PayloadType
+  ): StatePart<StatePartNameType, PayloadType> {
+    const newState = new StatePart<StatePartNameType, PayloadType>(statePartName);
+    newState.setState(initialPayloadArg);
+    this.statePartMap[statePartName as any] = newState;
+    return newState;
+  }
+}

package/ts/smartstate.classes.stateaction.ts

@@ -0,0 +1,20 @@
+import * as plugins from './smartstate.plugins.js';
+import { StatePart } from './smartstate.classes.statepart.js';
+
+export interface IActionDef<TStateType, TActionPayloadType> {
+  (stateArg: StatePart<any, TStateType>, actionPayload: TActionPayloadType): Promise<TStateType>;
+}
+
+/**
+ * an actionmodifier for the state
+ */
+export class StateAction<TStateType, TActionPayloadType> {
+  constructor(
+    public statePartRef: StatePart<any, any>,
+    public actionDef: IActionDef<TStateType, TActionPayloadType>
+  ) {}
+
+  public trigger(payload: TActionPayloadType) {
+    this.statePartRef.dispatchAction(this, payload);
+  }
+}

package/ts/smartstate.classes.statepart.ts

@@ -0,0 +1,127 @@
+import * as plugins from './smartstate.plugins.js';
+import { StateAction, IActionDef } from './smartstate.classes.stateaction.js';
+
+export class StatePart<TStatePartName, TStatePayload> {
+  public name: TStatePartName;
+  public state = new plugins.smartrx.rxjs.Subject<TStatePayload>();
+  public stateStore: TStatePayload;
+  private cumulativeDeferred = plugins.smartpromise.cumulativeDefer();
+
+  constructor(nameArg: TStatePartName) {
+    this.name = nameArg;
+  }
+
+  /**
+   * gets the state from the state store
+   */
+  public getState(): TStatePayload {
+    return this.stateStore;
+  }
+
+  /**
+   * sets the stateStore to the new state
+   * @param newStateArg
+   */
+  public setState(newStateArg: TStatePayload) {
+    this.stateStore = newStateArg;
+    this.notifyChange();
+  }
+
+  /**
+   * notifies of a change on the state
+   */
+  public notifyChange() {
+    const createStateHash = (stateArg: any) => {
+      return plugins.isohash.sha256FromString(plugins.smartjson.stringify(stateArg));
+    };
+    if (
+      this.stateStore &&
+      this.lastStateNotificationPayloadHash &&
+      createStateHash(this.stateStore) === this.lastStateNotificationPayloadHash
+    ) {
+      return;
+    } else {
+      this.lastStateNotificationPayloadHash = this.stateStore;
+    }
+    this.state.next(this.stateStore);
+  }
+  private lastStateNotificationPayloadHash: any;
+
+  /**
+   * creates a cumulative notification by adding a change notification at the end of the call stack;
+   */
+  public notifyChangeCumulative() {
+    // TODO: check viability
+    setTimeout(() => this.state.next(this.stateStore), 0);
+  }
+
+  /**
+   * selects a state or a substate
+   */
+  public select<T = TStatePayload>(
+    selectorFn?: (state: TStatePayload) => T
+  ): plugins.smartrx.rxjs.Observable<T> {
+    if (!selectorFn) {
+      selectorFn = (state: TStatePayload) => <T>(<any>state);
+    }
+    const mapped = this.state.pipe(
+      plugins.smartrx.rxjs.ops.startWith(this.getState()),
+      plugins.smartrx.rxjs.ops.map((stateArg) => {
+        try {
+          return selectorFn(stateArg);
+        } catch (e) {
+          // Nothing here
+        }
+      })
+    );
+    return mapped;
+  }
+
+  /**
+   * creates an action capable of modifying the state
+   */
+  public createAction<TActionPayload>(
+    actionDef: IActionDef<TStatePayload, TActionPayload>
+  ): StateAction<TStatePayload, TActionPayload> {
+    return new StateAction(this, actionDef);
+  }
+
+  /**
+   * dispatches an action on the statepart level
+   */
+  public async dispatchAction<T>(stateAction: StateAction<TStatePayload, T>, actionPayload: T) {
+    await this.cumulativeDeferred.promise;
+    const newState = await stateAction.actionDef(this, actionPayload);
+    this.setState(newState);
+  }
+
+  /**
+   * waits until a certain part of the state becomes available
+   * @param selectorFn
+   */
+  public async waitUntilPresent<T = TStatePayload>(
+    selectorFn?: (state: TStatePayload) => T
+  ): Promise<T> {
+    const done = plugins.smartpromise.defer<T>();
+    const selectedObservable = this.select(selectorFn);
+    const subscription = selectedObservable.subscribe(async (value) => {
+      if (value) {
+        done.resolve(value);
+      }
+    });
+    const result = await done.promise;
+    subscription.unsubscribe();
+    return result;
+  }
+
+  /**
+   * is executed
+   */
+  public async stateSetup(
+    funcArg: (statePartArg?: StatePart<any, TStatePayload>) => Promise<TStatePayload>
+  ) {
+    const resultPromise = funcArg(this);
+    this.cumulativeDeferred.addPromise(resultPromise);
+    this.setState(await resultPromise);
+  }
+}

package/ts/smartstate.plugins.ts

@@ -0,0 +1,6 @@
+import * as isohash from '@pushrocks/isohash';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+
+export { isohash, smartjson, smartpromise, smartrx };