refactor(overmind): first argument of TOperator is Context, TDerive takes resolved parent

Author: gaspard

packages/node_modules/overmind/src/index.ts

@@ -37,7 +37,11 @@ export type Action<Value = void> = TAction<App, Value>
 
 export type Context = TContext<App>
 
-export type Derive<Parent extends object, Value> = TDerive<App, Parent, Value>
+export type Derive<Parent extends object, Value> = TDerive<
+  App,
+  ResolveState<Parent>,
+  Value
+>
 
 export type Reaction = TReaction<App>
 
@@ -479,46 +483,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<Input, Output, Context>
+export type Operator<Input, Output> = TOperator<Context, Input, Output>
 
 export function pipe<BaseContext, A, B, C>(
-  aOperator: TOperator<A, B, BaseContext>
-): TOperator<A, C, BaseContext>
+  aOperator: TOperator<BaseContext, A, B>
+): TOperator<BaseContext, A, C>
 
 export function pipe<BaseContext, A, B, C, D>(
-  aOperator: TOperator<A, B, BaseContext>,
-  bOperator: TOperator<B, C, BaseContext>
-): TOperator<A, D, BaseContext>
+  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<A, B, BaseContext>,
-  bOperator: TOperator<B, C, BaseContext>,
-  cOperator: TOperator<C, D, BaseContext>
-): TOperator<A, E, BaseContext>
+  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<A, B, BaseContext>,
-  bOperator: TOperator<B, C, BaseContext>,
-  cOperator: TOperator<C, D, BaseContext>,
-  dOperator: TOperator<D, E, BaseContext>
-): TOperator<A, F, BaseContext>
+  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<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>
+  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<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>
+  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 function pipe(...operators) {
   const instance = (err, context, next, final = next) => {
@@ -632,7 +636,7 @@ function createNextPath(next) {
 
 export function map<Input, Output, BaseContext = Context>(
   operation: (input: TValueContext<BaseContext, Input>) => Output
-): TOperator<Input, Output extends Promise<infer U> ? U : Output, BaseContext> {
+): TOperator<BaseContext, Input, Output extends Promise<infer U> ? U : Output> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -650,7 +654,7 @@ export function map<Input, Output, BaseContext = Context>(
 
 export function run<Input, BaseContext = Context>(
   operation: (input: TValueContext<BaseContext, Input>) => any
-): TOperator<Input, Input, BaseContext> {
+): TOperator<BaseContext, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -672,8 +676,8 @@ export function run<Input, BaseContext = Context>(
 }
 
 export function forEach<Input extends any[], BaseContext = Context>(
-  forEachItemOperator: TOperator<Input[0], any, BaseContext>
-): TOperator<Input, Input, BaseContext> {
+  forEachItemOperator: TOperator<BaseContext, Input[0], any>
+): TOperator<BaseContext, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -715,8 +719,8 @@ export function forEach<Input extends any[], BaseContext = Context>(
 }
 
 export function parallel<Input, BaseContext = Context>(
-  operators: TOperator<Input, any, BaseContext>[]
-): TOperator<Input, Input, BaseContext> {
+  operators: TOperator<BaseContext, Input, any>[]
+): TOperator<BaseContext, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -758,7 +762,7 @@ export function parallel<Input, BaseContext = Context>(
 
 export function filter<Input, BaseContext = Context>(
   operation: (input: TValueContext<BaseContext, Input>) => boolean
-): TOperator<Input, Input, BaseContext> {
+): TOperator<BaseContext, Input, Input> {
   const instance = (err, context, next, final) => {
     if (err) next(err)
     else {
@@ -810,7 +814,7 @@ export function fork<
 >(
   operation: (input: TValueContext<BaseContext, Input>) => keyof Paths,
   paths: Paths
-): TOperator<Input, Input, BaseContext> {
+): TOperator<BaseContext, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -839,10 +843,10 @@ export function fork<
 export function when<Input, OutputA, OutputB, BaseContext = Context>(
   operation: (input: TValueContext<BaseContext, Input>) => boolean,
   paths: {
-    true: TOperator<Input, OutputA, BaseContext>
-    false: TOperator<Input, OutputB, BaseContext>
+    true: TOperator<BaseContext, Input, OutputA>
+    false: TOperator<BaseContext, Input, OutputB>
   }
-): TOperator<Input, OutputA | OutputB, BaseContext> {
+): TOperator<BaseContext, Input, OutputA | OutputB> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -875,7 +879,7 @@ export function when<Input, OutputA, OutputB, BaseContext = Context>(
 
 export function wait<Input, BaseContext = Context>(
   ms: number
-): TOperator<Input, Input, BaseContext> {
+): TOperator<BaseContext, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
@@ -891,7 +895,7 @@ export function wait<Input, BaseContext = Context>(
 
 export function debounce<Input, BaseContext = Context>(
   ms: number
-): TOperator<Input, Input, BaseContext> {
+): TOperator<BaseContext, Input, Input> {
   let timeout
   let previousFinal
   const instance = (err, context, next, final) => {

packages/node_modules/overmind/src/types.ts

@@ -40,7 +40,7 @@ export type TAction<App extends BaseApp, Value> = (
   context: TValueContext<TContext<App>, Value>
 ) => any
 
-export type TOperator<Input, Output, OperatorContext extends TContext<any>> = (
+export type TOperator<OperatorContext extends TContext<any>, Input, Output> = (
   err: Error | null,
   val: TValueContext<OperatorContext, Input>,
   next: (
@@ -51,13 +51,13 @@ export type TOperator<Input, Output, OperatorContext extends TContext<any>> = (
 ) => void
 
 export type TDerive<App extends BaseApp, Parent extends object, Value> = (
-  parent: ResolveState<Parent>,
+  parent: Parent,
   state: App['state']
 ) => Value
 
 export type TReaction<App extends BaseApp> = (
   reaction: (
     getState: (state: App['state']) => any,
-    action: TAction<App, void> | TOperator<void, any, TContext<App>>
+    action: TAction<App, void> | TOperator<TContext<App>, void, any>
   ) => any
 ) => any