Merge pull request cerebral#142 from cerebral/typesRefactor

refactor(overmind): refactor context to be static, allow operators to…

Author: christianalfoni

packages/node_modules/overmind-devtools/src/app/actions.ts

@@ -1,4 +1,4 @@
-import { Action, pipe, OnInitialize, Operator } from 'overmind'
+import { Action, pipe, OnInitialize, Operator, map } from 'overmind'
 import {
   Message,
   Tab,

packages/node_modules/overmind/src/index.ts

@@ -20,6 +20,7 @@ import {
   TDerive,
   TOperator,
   TReaction,
+  TValueContext,
 } from './types'
 
 export * from './types'
@@ -34,13 +35,15 @@ type App = BaseApp & IApp
 
 export type Action<Value = void> = TAction<App, Value>
 
-export type Context<Value> = TContext<App, Value>
+export type Context = TContext<App>
 
 export type Derive<Value, Parent = any> = TDerive<App, Value, Parent>
 
 export type Reaction = TReaction<App>
 
-export type OnInitialize = (context: Context<App['actions']>) => void
+export type OnInitialize = (
+  context: TValueContext<TContext<App>, App['actions']>
+) => void
 
 const isPlainObject = require('is-plain-object')
 const IS_PRODUCTION = process.env.NODE_ENV === 'production'
@@ -467,44 +470,46 @@ export class Overmind<Config extends Configuration> implements BaseApp {
   OPERATORS
   needs to be in this file for typing override to work
 */
-export type Operator<C, RC> = TOperator<Context<C>, Context<RC>>
-
-export function pipe<A, B, C>(aOperator: Operator<A, B>): Operator<A, C>
-
-export function pipe<A, B, C, D>(
-  aOperator: Operator<A, B>,
-  bOperator: Operator<B, C>
-): Operator<A, D>
-
-export function pipe<A, B, C, D, E>(
-  aOperator: Operator<A, B>,
-  bOperator: Operator<B, C>,
-  cOperator: Operator<C, D>
-): Operator<A, E>
-
-export function pipe<A, B, C, D, E, F>(
-  aOperator: Operator<A, B>,
-  bOperator: Operator<B, C>,
-  cOperator: Operator<C, D>,
-  dOperator: Operator<D, E>
-): Operator<A, F>
-
-export function pipe<A, B, C, D, E, F, G>(
-  aOperator: Operator<A, B>,
-  bOperator: Operator<B, C>,
-  cOperator: Operator<C, D>,
-  dOperator: Operator<D, E>,
-  eOperator: Operator<E, F>
-): Operator<A, G>
-
-export function pipe<A, B, C, D, E, F, G, H>(
-  aOperator: Operator<A, B>,
-  bOperator: Operator<B, C>,
-  cOperator: Operator<C, D>,
-  dOperator: Operator<D, E>,
-  eOperator: Operator<E, F>,
-  fOperator: Operator<F, G>
-): Operator<A, H>
+export type Operator<Input, Output> = TOperator<Input, Output, Context>
+
+export function pipe<BaseContext, A, B, C>(
+  aOperator: TOperator<A, B, BaseContext>
+): TOperator<A, C, BaseContext>
+
+export function pipe<BaseContext, A, B, C, D>(
+  aOperator: TOperator<A, B, BaseContext>,
+  bOperator: TOperator<B, C, BaseContext>
+): TOperator<A, D, BaseContext>
+
+export function pipe<BaseContext, A, B, C, D, E>(
+  aOperator: TOperator<A, B, BaseContext>,
+  bOperator: TOperator<B, C, BaseContext>,
+  cOperator: TOperator<C, D, BaseContext>
+): TOperator<A, E, BaseContext>
+
+export function pipe<BaseContext, A, B, C, D, E, F>(
+  aOperator: TOperator<A, B, BaseContext>,
+  bOperator: TOperator<B, C, BaseContext>,
+  cOperator: TOperator<C, D, BaseContext>,
+  dOperator: TOperator<D, E, BaseContext>
+): TOperator<A, F, BaseContext>
+
+export function pipe<BaseContext, A, B, C, D, E, F, G>(
+  aOperator: TOperator<A, B, BaseContext>,
+  bOperator: TOperator<B, C, BaseContext>,
+  cOperator: TOperator<C, D, BaseContext>,
+  dOperator: TOperator<D, E, BaseContext>,
+  eOperator: TOperator<E, F, BaseContext>
+): TOperator<A, G, BaseContext>
+
+export function pipe<BaseContext, A, B, C, D, E, F, G, H>(
+  aOperator: TOperator<A, B, BaseContext>,
+  bOperator: TOperator<B, C, BaseContext>,
+  cOperator: TOperator<C, D, BaseContext>,
+  dOperator: TOperator<D, E, BaseContext>,
+  eOperator: TOperator<E, F, BaseContext>,
+  fOperator: TOperator<F, G, BaseContext>
+): TOperator<A, H, BaseContext>
 
 export function pipe(...operators) {
   const instance = (err, context, next, final = next) => {
@@ -612,9 +617,9 @@ function createNextPath(next) {
   }
 }
 
-export function map<Input, Output>(
-  operation: (input: Context<Input>) => Output
-): Operator<Input, Output extends Promise<infer U> ? U : Output> {
+export function map<Input, Output, BaseContext = Context>(
+  operation: (input: TValueContext<BaseContext, Input>) => Output
+): TOperator<Input, Output extends Promise<infer U> ? U : Output, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -630,9 +635,9 @@ export function map<Input, Output>(
   return instance
 }
 
-export function run<Input>(
-  operation: (input: Context<Input>) => void
-): Operator<Input, Input> {
+export function run<Input, BaseContext = Context>(
+  operation: (input: TValueContext<BaseContext, Input>) => void
+): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -648,9 +653,9 @@ export function run<Input>(
   return instance
 }
 
-export function forEach<Input extends any[]>(
-  forEachItemOperator: Operator<Input[0], any>
-): Operator<Input, Input> {
+export function forEach<Input extends any[], BaseContext = Context>(
+  forEachItemOperator: TOperator<Input[0], any, BaseContext>
+): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -691,9 +696,9 @@ export function forEach<Input extends any[]>(
   return instance
 }
 
-export function parallel<Input>(
-  operators: Operator<Input, any>[]
-): Operator<Input, Input> {
+export function parallel<Input, BaseContext = Context>(
+  operators: TOperator<Input, any, BaseContext>[]
+): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -733,9 +738,9 @@ export function parallel<Input>(
   return instance
 }
 
-export function filter<Input>(
-  operation: (input: Context<Input>) => boolean
-): Operator<Input, Input> {
+export function filter<Input, BaseContext = Context>(
+  operation: (input: TValueContext<BaseContext, Input>) => boolean
+): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next, final) => {
     if (err) next(err)
     else {
@@ -756,8 +761,8 @@ export function filter<Input>(
   return instance
 }
 
-export function mutate<Input>(
-  operation: (input: Context<Input>) => void
+export function mutate<Input, BaseContext = Context>(
+  operation: (input: TValueContext<BaseContext, Input>) => void
 ): Operator<Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
@@ -782,11 +787,12 @@ export function mutate<Input>(
 
 export function fork<
   Input,
-  Paths extends { [key: string]: Operator<Input, any> }
+  Paths extends { [key: string]: Operator<Input, any> },
+  BaseContext = Context
 >(
-  operation: (input: Context<Input>) => keyof Paths,
+  operation: (input: TValueContext<BaseContext, Input>) => keyof Paths,
   paths: Paths
-): Operator<Input, Input> {
+): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -812,13 +818,13 @@ export function fork<
   return instance
 }
 
-export function when<Input, OutputA, OutputB>(
-  operation: (input: Context<Input>) => boolean,
+export function when<Input, OutputA, OutputB, BaseContext = Context>(
+  operation: (input: TValueContext<BaseContext, Input>) => boolean,
   paths: {
-    true: Operator<Input, OutputA>
-    false: Operator<Input, OutputB>
+    true: TOperator<Input, OutputA, BaseContext>
+    false: TOperator<Input, OutputB, BaseContext>
   }
-): Operator<Input, OutputA | OutputB> {
+): TOperator<Input, OutputA | OutputB, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -849,7 +855,9 @@ export function when<Input, OutputA, OutputB>(
   return instance
 }
 
-export function wait<Input>(ms: number): Operator<Input, Input> {
+export function wait<Input, BaseContext = Context>(
+  ms: number
+): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -863,7 +871,9 @@ export function wait<Input>(ms: number): Operator<Input, Input> {
   return instance
 }
 
-export function debounce<Input>(ms: number): Operator<Input, Input> {
+export function debounce<Input, BaseContext = Context>(
+  ms: number
+): TOperator<Input, Input, BaseContext> {
   let timeout
   let previousFinal
   const instance = (err, context, next, final) => {

packages/node_modules/overmind/src/internalTypes.ts

@@ -139,7 +139,10 @@ type TOperationValue<T> = T extends (
 
 type NestedActions =
   | {
-      [key: string]: TAction<any, any> | TOperator<any, any> | NestedActions
+      [key: string]:
+        | TAction<any, any>
+        | TOperator<any, any, any>
+        | NestedActions
     }
   | undefined
 
@@ -148,7 +151,7 @@ export type ResolveActions<Actions extends NestedActions> = {
     ? [TActionValue<Actions[T]>] extends [void]
       ? () => Promise<ReturnType<Actions[T]>>
       : (value: TActionValue<Actions[T]>) => Promise<ReturnType<Actions[T]>>
-    : Actions[T] extends TOperator<any, any>
+    : Actions[T] extends TOperator<any, any, any>
     ? [TOperationValue<Actions[T]>] extends [void]
       ? () => Promise<ReturnType<Actions[T]>>
       : (value: TOperationValue<Actions[T]>) => Promise<ReturnType<Actions[T]>>

packages/node_modules/overmind/src/reaction.test.ts

@@ -1,4 +1,4 @@
-import { Overmind, TAction, TApp, TReaction } from './'
+import { Overmind, TAction, TApp, TReaction, run, TContext } from './'
 
 describe('Reaction', () => {
   test('should instantiate app with reactions', () => {
@@ -34,13 +34,10 @@ describe('Reaction', () => {
   test('should react to nested changes', () => {
     let hasRunReaction = false
     const foo: Action = ({ state }) => (state.foo[0].completed = true)
-    const react: Reaction = (reaction) =>
-      reaction(
-        (state) => state.foo,
-        () => {
-          hasRunReaction = true
-        }
-      )
+    const hasRun = run<void, TContext<IApp>>(() => {
+      hasRunReaction = true
+    })
+    const react: Reaction = (reaction) => reaction((state) => state.foo, hasRun)
     const config = {
       state: {
         foo: [

packages/node_modules/overmind/src/types.ts

@@ -27,29 +27,37 @@ export interface TApp<Config extends Configuration> {
   effects: Config['effects'] & {}
 }
 
-export type TContext<App extends BaseApp, Value> = TBaseContext<App> & {
+export type TContext<App extends BaseApp> = TBaseContext<App>
+
+export type TValueContext<
+  BaseContext extends TContext<any>,
+  Value
+> = BaseContext & {
   value: Value
 }
 
 export type TAction<App extends BaseApp, Value> = (
-  context: TContext<App, Value>
+  context: TValueContext<TContext<App>, Value>
 ) => any
 
-export type TOperator<C, RC> = (
+export type TOperator<Input, Output, OperatorContext extends TContext<any>> = (
   err: Error | null,
-  val: C,
-  next: (err: Error | null, val?: RC) => void,
-  final?: (err, Error, val?: RC) => void
+  val: TValueContext<OperatorContext, Input>,
+  next: (
+    err: Error | null,
+    val?: TValueContext<OperatorContext, Output>
+  ) => void,
+  final?: (err, Error, val?: TValueContext<OperatorContext, Output>) => void
 ) => void
 
 export type TDerive<App extends BaseApp, Value, Parent = any> = (
-  state: App['state'],
-  parent: Parent
+  parent: Parent,
+  state: App['state']
 ) => Value
 
 export type TReaction<App extends BaseApp> = (
   reaction: (
     getState: (state: App['state']) => any,
-    action: TAction<App, void>
+    action: TAction<App, void> | TOperator<void, any, TContext<App>>
   ) => any
 ) => any