Added support for effects

Author: chorobinaccess

dist/main.js

@@ -2,4 +2,4 @@ import * as React from "react";
 import * as ReactDOM from "react-dom";
 import { HelloWorldContainer } from "./containers/hello-world/hello-world-container";
 
-ReactDOM.render(<HelloWorldContainer />, document.getElementById("app"));
+ReactDOM.render(<HelloWorldContainer anotherProp={"hi"} />, document.getElementById("app"));

index.tsx

@@ -6,8 +6,6 @@ export type ActionCreator<TActionType extends string = string, TPayload = null>
   ? (() => Action<TActionType>)
   : ((payload: TPayload) => Action<TActionType, TPayload>);
 
-export type PayloadOfActionCreator<TActionCreator> = TActionCreator extends ActionCreator<infer TActionType, infer TPayload>
-  ? (TPayload extends {} ? null : TPayload)
-  : never;
+export type PayloadOfActionCreator<TActionCreator> = TActionCreator extends ActionCreator<infer TActionType, infer TPayload> ? TPayload : never;
 
 export type ActionTypeOfActionCreator<TActionCreator> = TActionCreator extends ActionCreator<infer TActionType, infer TPayload> ? TActionType : never;

lib/action.ts

@@ -1,5 +1,5 @@
-import { Store, Dispatch } from "./store";
 import * as React from "react";
+import { Store } from "./store";
 import { Subscription } from "rxjs";
 import { Reducers } from "./reducer";
 import { ActionCreator } from "./action";
@@ -22,8 +22,8 @@ const mapSelectorProps = <TState, TSelectorProps extends SelectorProps<TState>,
   return stateProps;
 };
 
-const mapActionProps = <TState, TReducers, TActionProps, TProps, TActionKeys extends keyof TProps>(
-  store: Store<TState, TReducers>,
+const mapActionProps = <TState, TReducers, TActionProps, TProps, TActionKeys extends keyof TProps, TActions>(
+  store: Store<TState, TReducers, TActions>,
   actionProps: TActionProps,
 ) => {
   const dispatchProps = Object.keys(actionProps).reduce(
@@ -37,7 +37,7 @@ const mapActionProps = <TState, TReducers, TActionProps, TProps, TActionKeys ext
   return dispatchProps;
 };
 
-export const connect = <TState, TReducers extends Reducers<TState>>(store: Store<TState, TReducers>) => <
+export const connect = <TState, TReducers extends Reducers<TState>, TActions>(store: Store<TState, TReducers, TActions>) => <
   TSelectorProps extends SelectorProps<TState>,
   TActionProps extends ActionProps
 >(
@@ -49,7 +49,7 @@ export const connect = <TState, TReducers extends Reducers<TState>>(store: Store
 >(
   Component: React.ComponentType<TProps>,
 ): React.ComponentType<ExternalProps> => {
-  const dispatchProps = mapActionProps<TState, TReducers, TActionProps, TProps, keyof TActionProps>(store, actionProps);
+  const dispatchProps = mapActionProps<TState, TReducers, TActionProps, TProps, keyof TActionProps, TActions>(store, actionProps);
 
   return class extends React.Component<ExternalProps, { subscription: Subscription; stateProps: Pick<TProps, keyof TSelectorProps> }> {
     public constructor(props: ExternalProps) {

lib/connect.tsx

@@ -0,0 +1,27 @@
+import { Observable, merge } from "rxjs";
+import { Store } from "./store";
+import { scan, startWith, filter } from "rxjs/operators";
+import { Action } from "./action";
+import { Reducers } from "./reducer";
+
+export type Effect<TInputAction, TOutputAction, TState> = (action$: Observable<TInputAction>, state$: Observable<TState>) => Observable<TOutputAction>;
+
+export const useEffect = <TInputAction extends Action<string, unknown>, TOutputAction extends TInputAction, TState>(
+  effect: Effect<TInputAction, TOutputAction, TState>,
+) => <TReducers extends Reducers<TState, unknown>>(store: Store<TState, TReducers, TInputAction>) => {
+  const action$ = merge(store.action$, effect(store.action$, store.state$));
+  const state$ = action$.pipe(
+    scan((state: TState, action: TInputAction) => store.reducers[action.type](state, action.payload), store.initialState),
+    startWith(store.initialState),
+  );
+  const newStore: Store<TState, TReducers, TInputAction> = {
+    action$,
+    state$,
+    dispatch: store.dispatch,
+    initialState: store.initialState,
+    reducers: store.reducers,
+  };
+  return newStore;
+};
+
+export const ofType = <TActionType extends string>(actionType: TActionType) => filter((action: Action<string, unknown>) => action.type === actionType);

lib/effect.ts

@@ -0,0 +1,45 @@
+export type Right<T> = { readonly isLeft: false; readonly get: T };
+export type Left<T> = { readonly isLeft: true; readonly get: T };
+export type Either<TLeft, TRight> = Left<TLeft> | Right<TRight>;
+
+export function isLeft<TLeft, TRight>(either: Either<TLeft, TRight>): either is Left<TLeft> {
+  return either.isLeft;
+}
+
+export function isRight<TLeft, TRight>(either: Either<TLeft, TRight>): either is Right<TRight> {
+  return !isLeft(either);
+}
+
+export const right: <TRight>(right: TRight) => Right<TRight> = <TRight>(right: TRight) => ({
+  isLeft: false,
+  get: right,
+});
+
+export const left: <TLeft>(left: TLeft) => Left<TLeft> = <TLeft>(left: TLeft) => ({
+  isLeft: true,
+  get: left,
+});
+
+export const foldEither = <TLeft, TRight, TSeed>(mapLeft: (left: TLeft) => TSeed, mapRight: (right: TRight) => TSeed) => (either: Either<TLeft, TRight>) => {
+  if (isRight(either)) {
+    return mapRight(either.get);
+  } else if (isLeft(either)) {
+    return mapLeft(either.get);
+  }
+};
+
+export const mapEither = <TRight1, TRight2>(f: (val: TRight1) => TRight2) => <TLeft>(either: Either<TLeft, TRight1>) => {
+  if (isRight(either)) {
+    return right(f(either.get));
+  } else if (isLeft(either)) {
+    return either;
+  }
+};
+
+export const flatMapEither = <TRight1, TRight2, TLeft>(f: (val: TRight1) => Either<TLeft, TRight2>) => (either: Either<TLeft, TRight1>) => {
+  if (isRight(either)) {
+    return f(either.get);
+  } else if (isLeft(either)) {
+    return either;
+  }
+};

lib/either.ts

@@ -21,7 +21,7 @@ export const foldMaybe = <T, U>(defaultValue: U, f: (get: T) => U) => (maybe: Ma
   return result;
 };
 
-export const maybe = <T>(get: T) => (get ? just(get) : nothing);
+export const maybe = <T>(get: T) => (get ? just(get) : nothing) as Maybe<T>;
 export const mapMaybe = <T, U>(f: (get: T) => U) => foldMaybe(nothing as Maybe<U>, (get: T) => just(f(get)));
 export const filterMaybe = <T>(f: (get: T) => boolean) => foldMaybe(nothing as Maybe<T>, (get: T) => (f(get) ? just(get) : nothing));
 export const flatMapMaybe = <T, U>(f: (get: T) => Maybe<U>) => foldMaybe(nothing, f);

lib/maybe.ts

@@ -1,31 +1,39 @@
 import { Action } from "./action";
 import { Subject, Observable } from "rxjs";
 import { scan, startWith } from "rxjs/operators";
-import { Reducers, PayloadOfReducer } from "./reducer";
+import { PayloadOfReducer, Reducers } from "./reducer";
 
 export type Dispatch<TReducers> = <TActionType extends keyof TReducers & string>(action: Action<TActionType, PayloadOfReducer<TReducers[TActionType]>>) => void;
 
-export type Store<TState, TReducers> = {
-  action$: Observable<Action<string, PayloadOfReducer<TReducers[keyof TReducers]>>>;
+export type Store<TState, TReducers, TAction> = {
+  action$: Observable<TAction>;
   state$: Observable<TState>;
   dispatch: Dispatch<TReducers>;
+  reducers: TReducers;
+  initialState: TState;
 };
 
-export const createStore: <TState, TReducers>(initialState: TState, reducers: TReducers) => Store<TState, TReducers> = <TState, TReducers>(
+export const createStore: <TState, TReducers extends Reducers<TState, unknown>>(
+  initialState: TState,
+  reducers: TReducers,
+) => Store<TState, TReducers, Action<keyof TReducers & string, unknown>> = <
+  TState,
+  TReducers extends Reducers<TState, unknown>,
+  TActionTypes extends keyof TReducers & string
+>(
   initialState: TState,
   reducers: TReducers,
 ) => {
-  const action$ = new Subject<Action<string, PayloadOfReducer<TReducers[keyof TReducers]>>>();
+  const action$ = new Subject<Action<TActionTypes, unknown>>();
   const state$ = action$.pipe(
-    scan(
-      (state: TState, action: Action<string, PayloadOfReducer<TReducers[keyof TReducers]>>) => (reducers[action.type] as any)(state, (action as any).payload),
-      initialState,
-    ),
+    scan((state: TState, action: Action<TActionTypes, unknown>) => reducers[action.type](state, action.payload), initialState),
     startWith(initialState),
   );
   return {
+    initialState,
     action$: action$.asObservable(),
     state$: state$,
-    dispatch: <TActionType extends keyof TReducers & string>(action: Action<TActionType, PayloadOfReducer<TReducers[TActionType]>>) => action$.next(action),
+    dispatch: <TActionType extends TActionTypes & string>(action: Action<TActionType, PayloadOfReducer<TReducers[TActionType]>>) => action$.next(action),
+    reducers,
   };
 };