refactor(overmind): simplify types by removing Context and TContext and using App

Author: gaspard

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

@@ -1,4 +1,4 @@
-import { mutate, forEach, fork, Operator, when, map, EventType } from 'overmind'
+import { mutate, forEach, fork, Operator, when, map } from 'overmind'
 import {
   Message,
   AppMessage,

packages/node_modules/overmind/src/index.ts

@@ -1,6 +1,5 @@
 import { EventEmitter } from 'betsy'
 import { IS_PROXY, ProxyStateTree } from 'proxy-state-tree'
-
 import { Derived } from './derived'
 import { Devtools, Message, safeValue } from './Devtools'
 import {
@@ -16,7 +15,6 @@ import {
   BaseApp,
   Configuration,
   TAction,
-  TContext,
   TDerive,
   TOperator,
   TReaction,
@@ -35,8 +33,6 @@ type App = BaseApp & IApp
 
 export type Action<Value = void> = TAction<App, Value>
 
-export type Context = TContext<App>
-
 export type Derive<Parent extends object, Value> = TDerive<
   App,
   ResolveState<Parent>,
@@ -45,9 +41,7 @@ export type Derive<Parent extends object, Value> = TDerive<
 
 export type Reaction = TReaction<App>
 
-export type OnInitialize = (
-  context: TValueContext<TContext<App>, App['actions']>
-) => void
+export type OnInitialize = (context: TValueContext<App, App['actions']>) => void
 
 const isPlainObject = require('is-plain-object')
 const IS_PRODUCTION = process.env.NODE_ENV === 'production'
@@ -483,46 +477,46 @@ export class Overmind<Config extends Configuration> implements BaseApp {
   OPERATORS
   needs to be in this file for typing override to work
 */
-export type Operator<Input, Output> = TOperator<Context, Input, Output>
-
-export function pipe<BaseContext, A, B, C>(
-  aOperator: TOperator<BaseContext, A, B>
-): TOperator<BaseContext, A, C>
-
-export function pipe<BaseContext, A, B, C, D>(
-  aOperator: TOperator<BaseContext, A, B>,
-  bOperator: TOperator<BaseContext, B, C>
-): TOperator<BaseContext, A, D>
-
-export function pipe<BaseContext, A, B, C, D, E>(
-  aOperator: TOperator<BaseContext, A, B>,
-  bOperator: TOperator<BaseContext, B, C>,
-  cOperator: TOperator<BaseContext, C, D>
-): TOperator<BaseContext, A, E>
-
-export function pipe<BaseContext, A, B, C, D, E, F>(
-  aOperator: TOperator<BaseContext, A, B>,
-  bOperator: TOperator<BaseContext, B, C>,
-  cOperator: TOperator<BaseContext, C, D>,
-  dOperator: TOperator<BaseContext, D, E>
-): TOperator<BaseContext, A, F>
-
-export function pipe<BaseContext, A, B, C, D, E, F, G>(
-  aOperator: TOperator<BaseContext, A, B>,
-  bOperator: TOperator<BaseContext, B, C>,
-  cOperator: TOperator<BaseContext, C, D>,
-  dOperator: TOperator<BaseContext, D, E>,
-  eOperator: TOperator<BaseContext, E, F>
-): TOperator<BaseContext, A, G>
-
-export function pipe<BaseContext, A, B, C, D, E, F, G, H>(
-  aOperator: TOperator<BaseContext, A, B>,
-  bOperator: TOperator<BaseContext, B, C>,
-  cOperator: TOperator<BaseContext, C, D>,
-  dOperator: TOperator<BaseContext, D, E>,
-  eOperator: TOperator<BaseContext, E, F>,
-  fOperator: TOperator<BaseContext, F, G>
-): TOperator<BaseContext, A, H>
+export type Operator<Input, Output> = TOperator<App, Input, Output>
+
+export function pipe<App extends BaseApp, A, B, C>(
+  aOperator: TOperator<App, A, B>
+): TOperator<App, A, C>
+
+export function pipe<App extends BaseApp, A, B, C, D>(
+  aOperator: TOperator<App, A, B>,
+  bOperator: TOperator<App, B, C>
+): TOperator<App, A, D>
+
+export function pipe<App extends BaseApp, A, B, C, D, E>(
+  aOperator: TOperator<App, A, B>,
+  bOperator: TOperator<App, B, C>,
+  cOperator: TOperator<App, C, D>
+): TOperator<App, A, E>
+
+export function pipe<App extends BaseApp, A, B, C, D, E, F>(
+  aOperator: TOperator<App, A, B>,
+  bOperator: TOperator<App, B, C>,
+  cOperator: TOperator<App, C, D>,
+  dOperator: TOperator<App, D, E>
+): TOperator<App, A, F>
+
+export function pipe<App extends BaseApp, A, B, C, D, E, F, G>(
+  aOperator: TOperator<App, A, B>,
+  bOperator: TOperator<App, B, C>,
+  cOperator: TOperator<App, C, D>,
+  dOperator: TOperator<App, D, E>,
+  eOperator: TOperator<App, E, F>
+): TOperator<App, A, G>
+
+export function pipe<App extends BaseApp, A, B, C, D, E, F, G, H>(
+  aOperator: TOperator<App, A, B>,
+  bOperator: TOperator<App, B, C>,
+  cOperator: TOperator<App, C, D>,
+  dOperator: TOperator<App, D, E>,
+  eOperator: TOperator<App, E, F>,
+  fOperator: TOperator<App, F, G>
+): TOperator<App, A, H>
 
 export function pipe(...operators) {
   const instance = (err, context, next, final = next) => {
@@ -634,9 +628,9 @@ function createNextPath(next) {
   }
 }
 
-export function map<Input, Output, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => Output
-): TOperator<BaseContext, Input, Output extends Promise<infer U> ? U : Output> {
+export function map<Input, Output, TheApp extends BaseApp = App>(
+  operation: (input: TValueContext<TheApp, Input>) => Output
+): TOperator<TheApp, Input, Output extends Promise<infer U> ? U : Output> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -652,9 +646,9 @@ export function map<Input, Output, BaseContext = Context>(
   return instance
 }
 
-export function run<Input, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => any
-): TOperator<BaseContext, Input, Input> {
+export function run<Input, TheApp extends BaseApp = App>(
+  operation: (input: TValueContext<TheApp, Input>) => any
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -675,9 +669,9 @@ export function run<Input, BaseContext = Context>(
   return instance
 }
 
-export function forEach<Input extends any[], BaseContext = Context>(
-  forEachItemOperator: TOperator<BaseContext, Input[0], any>
-): TOperator<BaseContext, Input, Input> {
+export function forEach<Input extends any[], TheApp extends BaseApp = App>(
+  forEachItemOperator: TOperator<TheApp, Input[0], any>
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -718,9 +712,9 @@ export function forEach<Input extends any[], BaseContext = Context>(
   return instance
 }
 
-export function parallel<Input, BaseContext = Context>(
-  operators: TOperator<BaseContext, Input, any>[]
-): TOperator<BaseContext, Input, Input> {
+export function parallel<Input, TheApp extends BaseApp = App>(
+  operators: TOperator<TheApp, Input, any>[]
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -760,9 +754,9 @@ export function parallel<Input, BaseContext = Context>(
   return instance
 }
 
-export function filter<Input, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => boolean
-): TOperator<BaseContext, Input, Input> {
+export function filter<Input, TheApp extends BaseApp = App>(
+  operation: (input: TValueContext<TheApp, Input>) => boolean
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next, final) => {
     if (err) next(err)
     else {
@@ -783,9 +777,9 @@ export function filter<Input, BaseContext = Context>(
   return instance
 }
 
-export function mutate<Input, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => void
-): Operator<Input, Input> {
+export function mutate<Input, TheApp extends BaseApp = App>(
+  operation: (input: TValueContext<TheApp, Input>) => void
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -809,12 +803,12 @@ export function mutate<Input, BaseContext = Context>(
 
 export function fork<
   Input,
-  Paths extends { [key: string]: Operator<Input, any> },
-  BaseContext = Context
+  Paths extends { [key: string]: TOperator<TheApp, Input, any> },
+  TheApp extends BaseApp = App
 >(
-  operation: (input: TValueContext<BaseContext, Input>) => keyof Paths,
+  operation: (input: TValueContext<TheApp, Input>) => keyof Paths,
   paths: Paths
-): TOperator<BaseContext, Input, Input> {
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -840,13 +834,13 @@ export function fork<
   return instance
 }
 
-export function when<Input, OutputA, OutputB, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => boolean,
+export function when<Input, OutputA, OutputB, TheApp extends BaseApp = App>(
+  operation: (input: TValueContext<TheApp, Input>) => boolean,
   paths: {
-    true: TOperator<BaseContext, Input, OutputA>
-    false: TOperator<BaseContext, Input, OutputB>
+    true: TOperator<TheApp, Input, OutputA>
+    false: TOperator<TheApp, Input, OutputB>
   }
-): TOperator<BaseContext, Input, OutputA | OutputB> {
+): TOperator<TheApp, Input, OutputA | OutputB> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -877,9 +871,9 @@ export function when<Input, OutputA, OutputB, BaseContext = Context>(
   return instance
 }
 
-export function wait<Input, BaseContext = Context>(
+export function wait<Input, TheApp extends BaseApp = App>(
   ms: number
-): TOperator<BaseContext, Input, Input> {
+): TOperator<TheApp, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -893,9 +887,9 @@ export function wait<Input, BaseContext = Context>(
   return instance
 }
 
-export function debounce<Input, BaseContext = Context>(
+export function debounce<Input, TheApp extends BaseApp = App>(
   ms: number
-): TOperator<BaseContext, Input, Input> {
+): TOperator<TheApp, Input, Input> {
   let timeout
   let previousFinal
   const instance = (err, context, next, final) => {

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

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

packages/node_modules/overmind/src/types.ts

@@ -1,5 +1,4 @@
 import { ResolveActions, ResolveState, TBaseContext } from './internalTypes'
-import { Operator } from './'
 
 /** ===== PUBLIC API
  */
@@ -27,27 +26,19 @@ export interface TApp<Config extends Configuration> {
   effects: Config['effects'] & {}
 }
 
-export type TContext<App extends BaseApp> = TBaseContext<App>
-
-export type TValueContext<
-  BaseContext extends TContext<any>,
-  Value
-> = BaseContext & {
+export type TValueContext<App extends BaseApp, Value> = TBaseContext<App> & {
   value: Value
 }
 
 export type TAction<App extends BaseApp, Value> = (
-  context: TValueContext<TContext<App>, Value>
+  context: TValueContext<App, Value>
 ) => any
 
-export type TOperator<OperatorContext extends TContext<any>, Input, Output> = (
+export type TOperator<App extends BaseApp, Input, Output> = (
   err: Error | null,
-  val: TValueContext<OperatorContext, Input>,
-  next: (
-    err: Error | null,
-    val?: TValueContext<OperatorContext, Output>
-  ) => void,
-  final?: (err, Error, val?: TValueContext<OperatorContext, Output>) => void
+  val: TValueContext<App, Input>,
+  next: (err: Error | null, val?: TValueContext<App, Output>) => void,
+  final?: (err, Error, val?: TValueContext<App, Output>) => void
 ) => void
 
 export type TDerive<App extends BaseApp, Parent extends object, Value> = (
@@ -58,6 +49,6 @@ export type TDerive<App extends BaseApp, Parent extends object, Value> = (
 export type TReaction<App extends BaseApp> = (
   reaction: (
     getState: (state: App['state']) => any,
-    action: TAction<App, void> | TOperator<TContext<App>, void, any>
+    action: TAction<App, void> | TOperator<App, void, any>
   ) => any
 ) => any