@vanyamate/sec 0.0.8 → 0.1.0

package/README.md

@@ -0,0 +1,20 @@
+# SEC (Store, Effect, Combine)
+
+Tiny state manager
+
+```typescript
+import { store, effect, combine } from './index';
+
+
+const sum = async (a, b) => a + b;
+
+// Create effect
+const sumEffect = effect(sum);
+
+// Create stores
+const allSums = store(0).on(sumEffect, 'onSuccess', (state, { result }) => state + result);
+const lastSum = store(0).on(sumEffect, 'onSuccess', (_, { result }) => result);
+
+// Create combine
+const bothSum = combine([ allSums, lastSum ], (...args) => args.reduce((acc, item) => acc + item.get(), 0));
+```

package/index.d.ts

@@ -3,7 +3,7 @@ export type EffectEvent = 'onBefore' | 'onSuccess' | 'onError' | 'onFinally';
 export type Effect<Args extends any[], Result> = {
     (...args: Args): Promise<Result>;
     onSuccess: (callback: (result: Result, ...args: Args) => void) => void;
-    onError: (callback: (error: any, ...args: Args) => void) => void;
+    onError: (callback: (error: unknown, ...args: Args) => void) => void;
     onFinally: (callback: (...args: Args) => void) => void;
     onBefore: (callback: (...args: Args) => void) => void;
 };
@@ -14,12 +14,14 @@ export type Store<State> = {
     set: (newState: State) => void;
     on: <Args extends any[], Result>(effect: Effect<Args, Result>, event: EffectEvent, handler: (state: State, payload: {
         result?: Result;
-        error?: any;
-        meta: Args;
+        error?: unknown;
+        args: Args;
     }) => State) => Store<State>;
     subscribe: (listener: Listener<State>) => () => void;
 };
 export declare function store<State>(initialState: State): Store<State>;
-export declare function combine<States extends any[]>(...stores: {
+export declare function combine<States extends any[], Result>(stores: {
     [K in keyof States]: Store<States[K]>;
-}): Store<States>;
+}, callback: (...stores: {
+    [K in keyof States]: Store<States[K]>;
+}) => Result): Store<Result>;

package/index.ts

@@ -4,7 +4,7 @@ export type EffectEvent = 'onBefore' | 'onSuccess' | 'onError' | 'onFinally';
 export type Effect<Args extends any[], Result> = {
     (...args: Args): Promise<Result>;
     onSuccess: (callback: (result: Result, ...args: Args) => void) => void;
-    onError: (callback: (error: any, ...args: Args) => void) => void;
+    onError: (callback: (error: unknown, ...args: Args) => void) => void;
     onFinally: (callback: (...args: Args) => void) => void;
     onBefore: (callback: (...args: Args) => void) => void;
 };
@@ -14,10 +14,10 @@ export type Listener<State> = (state: State) => void;
 export function effect<Args extends any[], Result> (fn: EffectFunction<Args, Result>): Effect<Args, Result> {
     let beforeListeners: ((...args: Args) => void)[]                  = [];
     let successListeners: ((result: Result, ...args: Args) => void)[] = [];
-    let errorListeners: ((error: any, ...args: Args) => void)[]       = [];
+    let errorListeners: ((error: unknown, ...args: Args) => void)[]   = [];
     let finallyListeners: ((...args: Args) => void)[]                 = [];
 
-    const wrappedEffect: any = async (...args: Args) => {
+    const wrappedEffect: Effect<Args, Result> = async (...args: Args) => {
         beforeListeners.forEach(listener => listener(...args));
         try {
             const result = await fn(...args);
@@ -39,7 +39,7 @@ export function effect<Args extends any[], Result> (fn: EffectFunction<Args, Res
         successListeners.push(callback);
     };
 
-    wrappedEffect.onError = (callback: (error: any, ...args: Args) => void) => {
+    wrappedEffect.onError = (callback: (error: unknown, ...args: Args) => void) => {
         errorListeners.push(callback);
     };
 
@@ -47,7 +47,7 @@ export function effect<Args extends any[], Result> (fn: EffectFunction<Args, Res
         finallyListeners.push(callback);
     };
 
-    return wrappedEffect as Effect<Args, Result>;
+    return wrappedEffect;
 }
 
 export type Store<State> = {
@@ -58,8 +58,8 @@ export type Store<State> = {
         event: EffectEvent,
         handler: (state: State, payload: {
             result?: Result;
-            error?: any;
-            meta: Args
+            error?: unknown;
+            args: Args
         }) => State,
     ) => Store<State>;
     subscribe: (listener: Listener<State>) => () => void;
@@ -80,27 +80,27 @@ export function store<State> (initialState: State): Store<State> {
         event: EffectEvent,
         handler: (state: State, payload: {
             result?: Result;
-            error?: any;
-            meta: Args
+            error?: unknown;
+            args: Args
         }) => State,
     ): Store<State> => {
         const callback = (payload: {
             result?: Result;
-            error?: any;
-            meta: Args
+            error?: unknown;
+            args: Args
         }) => set(handler(state, payload));
 
         if (event === 'onBefore') {
-            effect.onBefore((...args) => callback({ meta: args }));
+            effect.onBefore((...args) => callback({ args }));
         } else if (event === 'onSuccess') {
             effect.onSuccess((result, ...args) => callback({
                 result,
-                meta: args,
+                args,
             }));
         } else if (event === 'onError') {
-            effect.onError((error, ...args) => callback({ error, meta: args }));
+            effect.onError((error, ...args) => callback({ error, args }));
         } else if (event === 'onFinally') {
-            effect.onFinally((...args) => callback({ meta: args }));
+            effect.onFinally((...args) => callback({ args }));
         }
 
         return storeApi;
@@ -108,7 +108,12 @@ export function store<State> (initialState: State): Store<State> {
 
     const subscribe = (listener: Listener<State>) => {
         listeners.push(listener);
-        return () => listeners = listeners.filter((l) => l !== listener);
+        return () => {
+            const index = listeners.indexOf(listener);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+        };
     };
 
     const storeApi = {
@@ -121,28 +126,43 @@ export function store<State> (initialState: State): Store<State> {
     return storeApi;
 }
 
-export function combine<States extends any[]> (...stores: { [K in keyof States]: Store<States[K]> }): Store<States> {
-    let combinedState                         = stores.map(store => store.get()) as States;
-    let combinedListeners: Listener<States>[] = [];
+export function combine<States extends any[], Result> (
+    stores: { [K in keyof States]: Store<States[K]> },
+    callback: (...stores: { [K in keyof States]: Store<States[K]> }) => Result,
+): Store<Result> {
+    let combinedState: Result = callback(...stores);
 
-    stores.forEach((store, index) => {
-        store.subscribe((state) => {
-            combinedState[index] = state;
-            combinedListeners.forEach(listener => listener(combinedState));
+    stores.forEach((store) => {
+        store.subscribe(() => {
+            combinedState = callback(...stores);
+            listeners.forEach(listener => listener(combinedState));
         });
     });
 
-    return {
-        get      : () => combinedState,
-        set      : (newState) => {
-            newState.forEach((state, index) => stores[index].set(state));
+    const listeners: Listener<Result>[] = [];
+
+    const get = () => combinedState;
+
+    const subscribe = (listener: Listener<Result>) => {
+        listeners.push(listener);
+        return () => {
+            const index = listeners.indexOf(listener);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    };
+
+    const storeApi: Store<Result> = {
+        get,
+        set: () => {
+            throw new Error('Cannot call \'set\' on combined store');
         },
-        on       : () => {
+        on : () => {
             throw new Error('Cannot call \'on\' on combined store');
         },
-        subscribe: (listener) => {
-            combinedListeners.push(listener);
-            return () => combinedListeners = combinedListeners.filter((l) => l !== listener);
-        },
+        subscribe,
     };
+
+    return storeApi;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vanyamate/sec",
-    "version": "0.0.8",
+    "version": "0.1.0",
     "description": "SEC. Store, Effect, Combine. Tiny state manager",
     "scripts": {
         "g:type": "tsc index.ts --declaration --emitDeclarationOnly"