feat(overmind): add waitUntil operator

Author: christianalfoni

packages/node_modules/overmind/src/index.ts

@@ -1511,6 +1511,8 @@ export function throttle<Input, ThisConfig extends IConfiguration = Config>(
   ms: number
 ): IOperator<ThisConfig, Input, Input> {
   let timeout
+  let previousFinal
+  let currentNext
 
   return createOperator(
     'throttle',
@@ -1519,13 +1521,38 @@ export function throttle<Input, ThisConfig extends IConfiguration = Config>(
       if (err) next(err, value)
       else {
         if (timeout) {
-          final(null, value)
+          previousFinal(null, value)
+          currentNext = next
         } else {
-          next(null, value)
           timeout = setTimeout(() => {
             timeout = null
+            currentNext(null, value)
           }, ms)
         }
+        previousFinal = final
+        currentNext = next
+      }
+    }
+  )
+}
+
+export function waitUntil<Input, ThisConfig extends IConfiguration = Config>(
+  operation: (state: ThisConfig['state']) => boolean
+): IOperator<ThisConfig, Input, Input> {
+  return createOperator<Config>(
+    'waitUntil',
+    operation.name,
+    (err, context, value, next) => {
+      if (err) next(err, value)
+      else {
+        const tree = context.execution.getTrackStateTree()
+        const test = () => {
+          if (operation(tree.state)) {
+            tree.dispose()
+            next(null, value)
+          }
+        }
+        tree.trackScope(test, test)
       }
     }
   )

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

@@ -16,6 +16,7 @@ import {
   catchError,
   tryCatch,
   throttle,
+  waitUntil,
 } from './'
 
 describe('OPERATORS', () => {
@@ -219,8 +220,6 @@ describe('OPERATORS', () => {
     interface Operator<Input = void, Output = Input>
       extends IOperator<Config, Input, Output> {}
 
-    interface Action<Input = void> extends IAction<Config, Input> {}
-
     return overmind.actions.test('foo').then(() => {
       expect(overmind.state.foo).toBe('FOO')
     })
@@ -320,7 +319,7 @@ describe('OPERATORS', () => {
   test('throttle', () => {
     expect.assertions(1)
     const test: Operator = pipe(
-      throttle(100),
+      throttle(0),
       mutate(({ state }) => state.runCount++)
     )
     const state = {
@@ -416,7 +415,7 @@ describe('OPERATORS', () => {
       expect(overmind.state.foo).toBe('baz')
     })
   })
-  test.only('tryCatch - fails', () => {
+  test('tryCatch - fails', () => {
     expect.assertions(1)
     const test: Operator<string> = pipe(
       tryCatch({
@@ -448,4 +447,39 @@ describe('OPERATORS', () => {
       expect(overmind.state.foo).toBe('ehm')
     })
   })
+  test('waitUntil', () => {
+    expect.assertions(1)
+    const increaseCount: Operator = pipe(
+      mutate(({ state }) => state.runCount++)
+    )
+    const test: Operator = pipe(
+      waitUntil((state) => state.runCount === 1),
+      mutate(({ state }) => (state.hasRun = true))
+    )
+    const state = {
+      runCount: 0,
+      hasRun: false,
+    }
+    const config = {
+      state,
+      actions: {
+        increaseCount,
+        test,
+      },
+    }
+    const overmind = new Overmind(config)
+
+    type Config = IConfig<typeof config>
+
+    interface Operator<Input = void, Output = Input>
+      extends IOperator<Config, Input, Output> {}
+
+    setTimeout(() => {
+      overmind.actions.increaseCount()
+    }, 0)
+
+    return overmind.actions.test().then(() => {
+      expect(overmind.state.runCount).toBe(1)
+    })
+  })
 })

packages/overmind-website/api/operators.md

@@ -121,6 +121,13 @@ Hold execution for set time.
 h(Example, { name: "api/operators_operator_wait" })
 ```
 
+## waitUntil
+Wait until a state condition is true.
+
+```marksy
+h(Example, { name: "api/operators_operator_waituntil" })
+```
+
 ## when
 Go down the true or false path based on the returned value.
 

packages/overmind-website/examples/api/operators_operator_waituntil.ts

@@ -0,0 +1,30 @@
+export default (ts) =>
+  ts
+    ? [
+        {
+          fileName: 'actions.ts',
+          code: `
+import { Operator, pipe, waitUntil } from 'overmind'
+import * as o from './operators'
+
+export const search: Operator<string> = pipe(
+  waitUntil(state => state.count === 3),
+  o.executeSomething()
+)
+`,
+        },
+      ]
+    : [
+        {
+          fileName: 'actions.js',
+          code: `
+import { pipe, waitUntil } from 'overmind'
+import * as o from './operators'
+
+export const search = pipe(
+  waitUntil(state => state.count === 3),
+  o.executeSomething()
+)
+`,
+        },
+      ]