Merge pull request cerebral#144 from cerebral/fixes2

Fixes2

Author: christianalfoni

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

@@ -20,15 +20,15 @@ type State = {
   expandedStatePaths: string[]
   expandAllActionDetails: boolean
   expandedComponents: string[]
-  currentAction: Derive<Action>
-  currentApp: Derive<App>
-  componentsMounted: Derive<Component[]>
-  componentsUpdateCount: Derive<number>
-  componentsStatePathCount: Derive<number>
-  flushes: Derive<Flush[]>
-  flushesMutationsCount: Derive<number>
-  flushesStatePathCount: Derive<number>
-  groupedComponents: Derive<GroupedComponents>
+  currentAction: Derive<Action, State>
+  currentApp: Derive<App, State>
+  componentsMounted: Derive<Component[], State>
+  componentsUpdateCount: Derive<number, State>
+  componentsStatePathCount: Derive<number, State>
+  flushes: Derive<Flush[], State>
+  flushesMutationsCount: Derive<number, State>
+  flushesStatePathCount: Derive<number, State>
+  groupedComponents: Derive<GroupedComponents, State>
 }
 
 const state: State = {

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

@@ -7,10 +7,13 @@ type State = {
 
 describe('Derived', () => {
   test('should instantiate app with derived state', () => {
-    const derived: Derive<string> = (state) => state.foo.toUpperCase()
-    const state = {
+    type State = {
+      foo: string
+      upperFoo: Derive<string, State>
+    }
+    const state: State = {
       foo: 'bar',
-      upperFoo: derived,
+      upperFoo: (state) => state.foo.toUpperCase(),
     }
     const config = {
       state,
@@ -20,7 +23,7 @@ describe('Derived', () => {
       state: typeof state
     }>
 
-    type Derive<Value> = TDerive<IApp, Value>
+    type Derive<Value, Parent extends object> = TDerive<IApp, Value, Parent>
 
     const app = new Overmind(config)
 
@@ -30,14 +33,17 @@ describe('Derived', () => {
   test('should track derived state', () => {
     let renderCount = 0
     const changeFoo: Action = ({ state }) => (state.foo = 'bar2')
-
-    const derived: Derive<string> = (state) => state.foo.toUpperCase()
+    type State = {
+      foo: string
+      upperFoo: Derive<string, State>
+    }
+    const state: State = {
+      foo: 'bar',
+      upperFoo: (state) => state.foo.toUpperCase(),
+    }
 
     const config = {
-      state: {
-        foo: 'bar',
-        upperFoo: derived,
-      },
+      state,
       actions: {
         changeFoo,
       },
@@ -50,7 +56,7 @@ describe('Derived', () => {
       actions: typeof config.actions
     }>
     type Action<Input = void> = TAction<IApp, Input>
-    type Derive<Value> = TDerive<IApp, Value>
+    type Derive<Value, Parent extends object> = TDerive<IApp, Value, Parent>
 
     const app = new Overmind(config)
     function render() {
@@ -67,18 +73,21 @@ describe('Derived', () => {
   })
   test('should not require flush to flag as dirty', () => {
     expect.assertions(1)
+    type State = {
+      foo: string
+      upperFoo: Derive<string, State>
+    }
+    const state: State = {
+      foo: 'bar',
+      upperFoo: (state) => state.foo.toUpperCase(),
+    }
     const changeFoo: Action = ({ state }) => {
       state.foo = 'bar2'
       expect(state.upperFoo).toBe('BAR2')
     }
 
-    const derived: Derive<string> = (state) => state.foo.toUpperCase()
-
     const config = {
-      state: {
-        foo: 'bar',
-        upperFoo: derived,
-      },
+      state,
       actions: {
         changeFoo,
       },
@@ -91,7 +100,7 @@ describe('Derived', () => {
       actions: typeof config.actions
     }>
     type Action<Input = void> = TAction<IApp, Input>
-    type Derive<Value> = TDerive<IApp, Value>
+    type Derive<Value, Parent extends object> = TDerive<IApp, Value, Parent>
 
     const app = new Overmind(config)
 
@@ -124,7 +133,7 @@ describe('Derived', () => {
       actions: typeof config.actions
     }>
     type Action<Input = void> = TAction<IApp, Input>
-    type Derive<Value, Parent = any> = TDerive<IApp, Value, Parent>
+    type Derive<Value, Parent extends object> = TDerive<IApp, Value, Parent>
 
     const app = new Overmind(config)
 

packages/node_modules/overmind/src/index.ts

@@ -37,7 +37,7 @@ export type Action<Value = void> = TAction<App, Value>
 
 export type Context = TContext<App>
 
-export type Derive<Value, Parent = any> = TDerive<App, Value, Parent>
+export type Derive<Value, Parent extends object> = TDerive<App, Value, Parent>
 
 export type Reaction = TReaction<App>
 
@@ -527,6 +527,10 @@ export function pipe(...operators) {
           return next(null, operatorContext)
 
         if (operatorContext.value instanceof Promise) {
+          context.execution.emit(EventType.OPERATOR_ASYNC, {
+            ...context.execution,
+            isAsync: true,
+          })
           operatorContext.value
             .then((promiseValue) =>
               run(null, { ...operatorContext, value: promiseValue })
@@ -638,14 +642,19 @@ export function map<Input, Output, BaseContext = Context>(
 }
 
 export function run<Input, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => void
+  operation: (input: TValueContext<BaseContext, Input>) => any
 ): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
       startDebugOperator('run', operation, context)
-      operation(context)
-      const newContext = createContext(context, context.value)
+      const result = operation(context)
+      const newContext = createContext(
+        context,
+        result instanceof Promise
+          ? result.then(() => context.value)
+          : context.value
+      )
       stopDebugOperator(newContext)
       next(null, newContext)
     }

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

@@ -180,5 +180,19 @@ describe('PIPE', () => {
         expect(value).toEqual('foo')
       })
     })
+    test('run (async)', () => {
+      expect.assertions(2)
+      let hasRun = false
+      const test: Operator<string, string> = pipe(
+        run(({ value }) => Promise.resolve(value + '!!!')),
+        run(() => (hasRun = true))
+      )
+      const action = createMockAction(test)
+      const actionRun = action('foo')
+      expect(hasRun).toBe(false)
+      return actionRun.then((value) => {
+        expect(value).toEqual('foo')
+      })
+    })
   })
 })

packages/node_modules/overmind/src/types.ts

@@ -50,8 +50,8 @@ export type TOperator<Input, Output, OperatorContext extends TContext<any>> = (
   final?: (err, Error, val?: TValueContext<OperatorContext, Output>) => void
 ) => void
 
-export type TDerive<App extends BaseApp, Value, Parent = any> = (
-  parent: Parent,
+export type TDerive<App extends BaseApp, Value, Parent extends object = {}> = (
+  parent: ResolveState<Parent>,
   state: App['state']
 ) => Value
 

packages/overmind-website/api/operators.md

@@ -71,7 +71,8 @@ h(Example, { name: "api/operators_operator_pipe" })
 ```
 
 ## run
-This operator is useful to run effects. It will just pass the current value a long.
+This operator is useful to run effects. It will just pass the current value a long. You may return a promise which will hold further
+execution until it is resolved.
 
 ```marksy
 h(Example, { name: "api/operators_operator_run" })