danholibraryjs 1.7.0 → 1.8.0

package/dist/Classes/Events/EventEmitter.d.ts

@@ -4,6 +4,30 @@ import { BaseEvent, EventHandler } from '../../Types';
  * @borrows EventCollection
  * @borrows BaseEvent
  * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
 export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/

package/dist/Classes/Events/EventEmitter.js

@@ -10,6 +10,30 @@ const EventCollection_1 = __importDefault(require("./EventCollection"));
  * @borrows EventCollection
  * @borrows BaseEvent
  * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
 class EventEmitter {
     /**@param events Map<name: string, handlers: EventHandler[]>*/

package/dist/Classes/store.d.ts

@@ -0,0 +1,79 @@
+import { Arrayable } from "../Types";
+import { EventEmitter } from "./Events";
+export declare type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State;
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+export declare class Store<State extends object, ActionTypes extends Record<string, any[]>, Actions extends {
+    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
+} = {
+    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
+}> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions?: {
+        [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>>;
+    });
+    private _state;
+    get state(): State;
+    dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State;
+}
+export default Store;

package/dist/Classes/store.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+const Events_1 = require("./Events");
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+class Store extends Events_1.EventEmitter {
+    constructor(state, actions = {}) {
+        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers])));
+        this._state = state;
+    }
+    _state;
+    get state() {
+        return this._state;
+    }
+    dispatch(action, ...args) {
+        const previous = { ...this._state };
+        this._state = super.emit(action, ...args).reduce((state, returned) => ({ ...state, ...returned }), this.state);
+        super.emit('stateChange', ...[previous, this.state]);
+        return this.state;
+    }
+}
+exports.Store = Store;
+exports.default = Store;

package/docs/Classes.md

@@ -2,6 +2,39 @@
 
 ## Classes
 
+```ts
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ * 
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ * 
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType. 
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ * 
+ * Reducer functions can be removed using Store.off('action', reducer);
+ * 
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ */
+class Store<
+    State extends object,
+    ActionTypes extends Record<string, any[]>,
+    Actions extends 
+    { [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>> } = 
+    { [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>> }
+> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions: { [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>> } = {});
+
+    private _state: State;
+    public get state(): State;
+
+    public dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State;
+}
+```
+
 ### Events
 
 ```ts

package/docs/Types.md

@@ -127,3 +127,11 @@ export type TransformTypes<From, BaseType, NewType> = Record<keyof {
     [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key 
 }, NewType>
 ```
+
+### Store
+```ts
+/**
+ * Reducer function to map wanted parameters when using @see Store.on(action, reducer);
+ */
+export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "danholibraryjs",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Library for Javascript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Classes/Events/EventEmitter.ts

@@ -6,6 +6,30 @@ import { BaseEvent, EventHandler } from '../../Types';
  * @borrows EventCollection
  * @borrows BaseEvent
  * @borrows EventHandler
+ * 
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ * 
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ * 
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ * 
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
 export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/

package/src/Classes/store.ts

@@ -0,0 +1,95 @@
+import { Arrayable } from "../Types";
+import { EventEmitter } from "./Events";
+
+export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State
+
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ * 
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ * 
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType. 
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ * 
+ * Reducer functions can be removed using Store.off('action', reducer);
+ * 
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ * 
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ * 
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ * 
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ * 
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, { 
+ *          id: Math.random().toString(), 
+ *          text, 
+ *          completed: false 
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ * 
+ *      return state.map(todo => (
+ *          todo.id === id ? { 
+ *              ...todo, 
+ *              completed: force === undefined ? !todo.completed : force 
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ * 
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ * 
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ * 
+ * store.dispatch('create', 'Make store!');
+ * 
+ * ```
+ */
+export class Store<
+    State extends object,
+    ActionTypes extends Record<string, any[]>,
+    Actions extends 
+    { [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>> } = 
+    { [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>> }
+> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions: { [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>> } = {}) {
+        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers as any])));
+
+        this._state = state;
+    }
+
+    private _state: State;
+    public get state(): State {
+        return this._state;
+    }
+
+    public dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State {
+        const previous = { ...this._state };
+        this._state = super.emit<State, Action>(action, ...args as any).reduce((state, returned) => ({ ...state, ...returned }), this.state);
+
+        super.emit<void, 'stateChange'>('stateChange', ...[previous, this.state] as any);
+        return this.state;
+    }
+}
+export default Store;