docs(website): update docs to fit Operator type

Author: christianalfoni

packages/overmind-website/api/operators.md

@@ -0,0 +1,87 @@
+# Operators
+
+Overmind also provides a functional API to help you manage complex logic. This API is inspired by asynchronous flow libraries like RxJS, though it is a simpler approach. You define an operator just like an action:
+
+```marksy
+h(Example, { name: "api/operators" })
+```
+
+Operators forces you to split up your logic in tiny composable pieces that has a specific purpose. This allows you to express complexity in a declarative way. You typically use the **pipe** operator in combination with the other operators to do this:
+
+```marksy
+h(Example, { name: "api/operators_pipe" })
+```
+
+Any of these operators can be used with other operators. You can even insert a pipe inside an other pipe. This kind of composition is what makes functional programming so powerful.
+
+## debounce
+When action is called multiple times within the set time limit, only the last action will move beyond the point of the debounce.
+
+```marksy
+h(Example, { name: "api/operators_operator_debounce" })
+```
+
+## filter
+Stop execution if it returns false.
+
+```marksy
+h(Example, { name: "api/operators_operator_filter" })
+```
+
+## forEach
+Allows you to point to an array where each item will be sent to the operator/pipe on the second argument.
+
+```marksy
+h(Example, { name: "api/operators_operator_forEach" })
+```
+
+## fork
+Allows you to execute an operator/pipe based on the matching key.
+
+```marksy
+h(Example, { name: "api/operators_operator_fork" })
+```
+
+## map
+Returns a new value to the pipe. If the value is a promise it will wait until promise is resolved.
+
+```marksy
+h(Example, { name: "api/operators_operator_map" })
+```
+
+## mutate
+You are only allowed to change the state in the mutate operator.
+
+```marksy
+h(Example, { name: "api/operators_operator_mutate" })
+```
+
+## pipe
+The pipe is an operator in itself. Use it to compose other operators and pipes.
+
+```marksy
+h(Example, { name: "api/operators_operator_pipe" })
+```
+
+## run
+This operator is useful to run effects. It will just pass the current value a long.
+
+```marksy
+h(Example, { name: "api/operators_operator_run" })
+```
+
+## wait
+Hold execution for set time.
+
+```marksy
+h(Example, { name: "api/operators_operator_wait" })
+```
+
+## when
+Go down the true or false path based on the returned value.
+
+```marksy
+h(Example, { name: "api/operators_operator_when" })
+```
+
+

packages/overmind-website/api/pipe.md

@@ -0,0 +1,24 @@
+export default (ts) =>
+  ts
+    ? [
+        {
+          code: `
+import { mutate } from 'overmind'
+
+export const changeFoo = mutate(({ state }) => {
+  state.foo = 'bar'
+})
+`,
+        },
+      ]
+    : [
+        {
+          code: `
+import { mutate } from 'overmind'
+
+export const changeFoo = mutate(({ state }) => {
+  state.foo = 'bar'
+})
+`,
+        },
+      ]

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

@@ -3,10 +3,10 @@ export default (ts) =>
     ? [
         {
           code: `
-import { Pipe, pipe, debounce } from 'overmind'
+import { Operator, pipe, debounce } from 'overmind'
 import { performSearch } from './operators'
 
-export const search: Pipe<string, string> = pipe(
+export const search: Operator<string, string> = pipe(
   debounce(200),
   performSearch
 )

…nd-website/examples/api/pipe_debounce.ts …mples/api/operators_operator_debounce.tspackages/overmind-website/examples/api/pipe_debounce.ts renamed to packages/overmind-website/examples/api/operators_operator_debounce.ts packages/overmind-website/examples/api/pipe_debounce.ts renamed to packages/overmind-website/examples/api/operators_operator_debounce.ts

@@ -3,11 +3,11 @@ export default (ts) =>
     ? [
         {
           code: `
-import { Pipe, pipe, forEach } from 'overmind'
+import { Operator, pipe, forEach } from 'overmind'
 import { Post } from './state'
 import { getPosts, getAuthor, setAuthor } from './operators'
 
-export const openPosts: Pipe<string, Post[]> = pipe(
+export const openPosts: Operator<string, Post[]> = pipe(
   getPosts,
   forEach(pipe(
     getAuthor,

…mind-website/examples/api/pipe_filter.ts …xamples/api/operators_operator_filter.tspackages/overmind-website/examples/api/pipe_filter.ts renamed to packages/overmind-website/examples/api/operators_operator_filter.ts packages/overmind-website/examples/api/pipe_filter.ts renamed to packages/overmind-website/examples/api/operators_operator_filter.ts

@@ -15,10 +15,10 @@ export const forkUserType = (paths: {
         {
           fileName: 'app/actions.ts',
           code: `
-import { Pipe, pipe } from 'overmind'
+import { Operator, pipe } from 'overmind'
 import { forkUserType, doThis, doThat } from './operators'
 
-export const getUser: Pipe<string> = pipe(
+export const getUser: Operator<string> = pipe(
   getUser,
   forkUserType({
     admin: doThis,

…ind-website/examples/api/pipe_forEach.ts …amples/api/operators_operator_forEach.tspackages/overmind-website/examples/api/pipe_forEach.ts renamed to packages/overmind-website/examples/api/operators_operator_forEach.ts packages/overmind-website/examples/api/pipe_forEach.ts renamed to packages/overmind-website/examples/api/operators_operator_forEach.ts

@@ -6,7 +6,7 @@ export default (ts) =>
 import { map } from 'overmind'
 import { User } from './state'
 
-export const getUser = map<string, User>(({ api }) => api.getUser())
+export const getUser = map<any, User>(({ api }) => api.getUser())
 `,
         },
       ]

…ermind-website/examples/api/pipe_fork.ts …/examples/api/operators_operator_fork.tspackages/overmind-website/examples/api/pipe_fork.ts renamed to packages/overmind-website/examples/api/operators_operator_fork.ts packages/overmind-website/examples/api/pipe_fork.ts renamed to packages/overmind-website/examples/api/operators_operator_fork.ts

@@ -3,15 +3,15 @@ export default (ts) =>
     ? [
         {
           code: `
-import { Pipe, pipe } from 'overmind'
+import { Operator, pipe } from 'overmind'
 import { Item } from './state'
 
-export const openItems: Pipe<void, Item[]> = pipe(
+export const openItems: Operator<void, Item[]> = pipe(
   getItems,
   setItems
 )
 
-export const openItem: Pipe<void, Item> = pipe(
+export const openItem: Operator<void, Item> = pipe(
   openItems,
   getItem,
   setItem