Merge pull request cerebral#133 from cerebral/improvements3

Improvements3

Author: christianalfoni

packages/demos/react-typescript-todomvc/src/app/actions.ts

@@ -1,5 +1,6 @@
 import * as React from 'react'
 import { Action } from 'overmind'
+import { Todo } from './state'
 
 type ChangeEvent = React.ChangeEvent<HTMLInputElement>
 
@@ -21,7 +22,6 @@ export const addTodo: Action = ({ state }) => {
   state.newTodoTitle = ''
 }
 
-export const toggleCompleted: Action<string> = ({ value: todoId, state }) => {
-  const todo = state.todos.find((todo) => todo.id === todoId)
+export const toggleCompleted: Action<Todo> = ({ value: todo }) => {
   todo.completed = !todo.completed
 }

packages/demos/react-typescript-todomvc/src/components/Todo/index.tsx

@@ -8,7 +8,7 @@ type Props = {
 } & Connect
 
 const Todo: React.SFC<Props> = ({ todo, app }) => (
-  <Item onClick={() => app.actions.toggleCompleted(todo.id)}>
+  <Item onClick={() => app.actions.toggleCompleted(todo)}>
     <Completed completed={todo.completed}>✔</Completed> {todo.title}
   </Item>
 )

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

@@ -8,6 +8,9 @@ function toJSON(obj) {
 function createDefaultApp() {
   const state = {
     foo: 'bar',
+    item: {
+      isAwesome: true,
+    },
   }
   const changeFoo: Action = (context) => {
     context.state.foo = 'bar2'
@@ -24,11 +27,15 @@ function createDefaultApp() {
     await Promise.resolve()
     context.state.foo = 'bar2'
   }
+  const changeValue: Action<{ isAwesome: boolean }> = (context) => {
+    context.value.isAwesome = !context.value.isAwesome
+  }
   const actions = {
     changeFoo,
     changeFooWithEffect,
     waitAndChangeFoo,
     asyncChangeFoo,
+    changeValue,
   }
   const effects = {
     hello() {
@@ -49,11 +56,7 @@ function createDefaultApp() {
     actions: typeof actions
     effects: typeof effects
   }>
-  type Action<Value = void, ReturnValue = Value> = TAction<
-    App,
-    Value,
-    ReturnValue
-  >
+  type Action<Value = void> = TAction<App, Value>
 
   return new Overmind(config)
 }
@@ -296,4 +299,10 @@ describe('Overmind', () => {
       expect(result).toEqual(['foo', 'bar'])
     })
   })
+  test('should allow mutations on passed values', () => {
+    expect.assertions(2)
+    const app = createDefaultApp()
+    expect(() => app.actions.changeValue(app.state.item)).not.toThrow()
+    expect(app.state.item.isAwesome).toBe(false)
+  })
 })

packages/node_modules/overmind/src/index.ts

@@ -31,11 +31,7 @@ export interface IApp {}
 
 type App = BaseApp & IApp
 
-export type Action<Value = void, ReturnValue = any> = TAction<
-  App,
-  Value,
-  ReturnValue
->
+export type Action<Value = void> = TAction<App, Value>
 
 export type Context<Value> = TContext<App, Value>
 
@@ -215,7 +211,11 @@ export class Overmind<Config extends Configuration> implements BaseApp {
         const scopedTree = this.proxyStateTree.getScopedTree()
         scopedTree.startMutationTracking()
         const result = action(
-          this.createContext(value, execution, scopedTree.get())
+          this.createContext(
+            scopedTree.scope(value),
+            execution,
+            scopedTree.get()
+          )
         )
         this.eventHub.emit(EventType.OPERATOR_END, {
           ...execution,
@@ -559,7 +559,7 @@ function startDebugOperator(type, operationName, execution) {
 export function map<Input, Output>(
   operation: (input: Context<Input>) => Output
 ): Operator<Input, Output extends Promise<infer U> ? U : Output> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) next(err)
     else {
       const stopDebugOperator = startDebugOperator(
@@ -572,12 +572,15 @@ export function map<Input, Output>(
       next(null, { ...context, value } as any)
     }
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function run<Input>(
   operation: (input: Context<Input>) => void
 ): Operator<Input, Input> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) next(err)
     else {
       const stopDebugOperator = startDebugOperator(
@@ -590,12 +593,15 @@ export function run<Input>(
       next(null, context as any)
     }
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function forEach<Input extends any[]>(
   forEachItemOperator: Operator<Input[0], any>
 ): Operator<Input, Input> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) next(err)
     else {
       const stopDebugOperator = startDebugOperator(
@@ -627,22 +633,28 @@ export function forEach<Input extends any[]>(
       )
     }
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function filter<Input>(
   operation: (input: Context<Input>) => boolean
 ): Operator<Input, Input> {
-  return (err, context, next, final) => {
+  const instance = (err, context, next, final) => {
     if (err) next(err)
     else if (operation(context)) next(null, context)
     else final(null, context)
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function mutate<Input>(
   operation: (input: Context<Input>) => void
 ): Operator<Input, Input> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) next(err)
     else {
       const operatorId = context.execution.operatorId
@@ -663,6 +675,9 @@ export function mutate<Input>(
       next(null, context)
     }
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function fork<
@@ -672,13 +687,16 @@ export function fork<
   operation: (input: Context<Input>) => keyof Paths,
   paths: Paths
 ): Operator<Input, Input> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) return next(err)
     paths[operation(context)](null, context, (err) => {
       if (err) next(err)
       else next(null, context)
     })
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function when<Input, OutputA, OutputB>(
@@ -688,24 +706,30 @@ export function when<Input, OutputA, OutputB>(
     false: Operator<Input, OutputB>
   }
 ): Operator<Input, OutputA | OutputB> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) next(err)
     else if (operation(context)) paths.true(null, context, next)
     else paths.false(null, context, next)
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function wait<Input>(ms: number): Operator<Input, Input> {
-  return (err, context, next) => {
+  const instance = (err, context, next) => {
     if (err) next(err)
     else setTimeout(() => next(null, context), ms)
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }
 
 export function debounce<Input>(ms: number): Operator<Input, Input> {
   let timeout
   let previousFinal
-  return (err, value, next, final) => {
+  const instance = (err, value, next, final) => {
     if (err) {
       return next(err)
     }
@@ -719,4 +743,7 @@ export function debounce<Input>(ms: number): Operator<Input, Input> {
       next(null, value)
     }, ms)
   }
+  instance[IS_PIPE] = true
+
+  return instance
 }

packages/node_modules/overmind/src/modules.ts

@@ -1,11 +1,6 @@
 import { Configuration } from './'
 import { ResolveState, ResolveActions } from './internalTypes'
 
-type SubType<Base, Condition> = Pick<
-  Base,
-  { [Key in keyof Base]: Base[Key] extends Condition ? Key : never }[keyof Base]
->
-
 interface ConfigurationWithModules extends Configuration {
   [namespace: string]: {
     onInitialize?: any
@@ -43,7 +38,7 @@ export function modules<T extends ConfigurationWithModules>(
   onInitialize?: any
   state: { [P in keyof T]: ResolveState<T[P]['state']> }
   effects: { [P in keyof T]: T[P]['effects'] }
-  actions: { [P in keyof T]: ResolveActions<T[P]['state']> }
+  actions: { [P in keyof T]: ResolveActions<T[P]['actions']> }
 } {
   const result: any = {
     initializers: [],

packages/node_modules/overmind/src/types.ts

@@ -31,9 +31,9 @@ export type TContext<App extends BaseApp, Value> = TBaseContext<App> & {
   value: Value
 }
 
-export type TAction<App extends BaseApp, Value, ReturnValue = Value> = (
+export type TAction<App extends BaseApp, Value> = (
   context: TContext<App, Value>
-) => ReturnValue
+) => any
 
 export type TOperator<C, RC> = (
   err: Error,

packages/node_modules/proxy-state-tree/src/index.test.ts

@@ -951,4 +951,30 @@ describe('SCOPED', () => {
     expect(tree.get().foo).toBe('bar2')
     expect(scoped.get().foo).toBe('bar2')
   })
+  it('should be able to change scope of state', () => {
+    const tree = new ProxyStateTree({
+      foo: 'bar',
+    })
+
+    const scoped = tree.getScopedTree()
+    const changeScope = scoped.scope(tree.get())
+
+    scoped.startMutationTracking()
+    changeScope.foo = 'bar2'
+    scoped.clearMutationTracking()
+    expect(tree.get().foo).toBe('bar2')
+    expect(scoped.get().foo).toBe('bar2')
+  })
+  it('should not recreate proxy when exists', () => {
+    const tree = new ProxyStateTree({
+      foo: {
+        bar: 'baz',
+      },
+    })
+
+    const state = tree.get()
+
+    // eslint-disable-next-line
+    expect(state.foo === state.foo).toBe(true)
+  })
 })

packages/node_modules/proxy-state-tree/src/index.ts

@@ -74,6 +74,11 @@ export class ProxyStateTree {
 
     return instance
   }
+  scope(value) {
+    return value && value[IS_PROXY]
+      ? proxify(this, value[VALUE], value[PATH])
+      : value
+  }
   addTrackingPath(path) {
     if (this.status.has(STATUS.TRACKING_PATHS)) {
       this.paths[this.paths.length - 1].add(path)

packages/node_modules/proxy-state-tree/src/proxify.ts

@@ -186,15 +186,16 @@ function getValue(value, tree) {
     return value
   }
 
-  if (value[IS_PROXY]) {
-    return value[VALUE][tree.PROXY] || value[VALUE]
+  if (value[tree.PROXY]) {
+    return value[tree.PROXY]
   }
 
   return value
 }
 
 export function proxify(tree, value, path?) {
   value = getValue(value, tree)
+
   if (value) {
     if (value[IS_PROXY] && value[PATH] !== path) {
       delete value[VALUE][tree.PROXY]
@@ -210,6 +211,7 @@ export function proxify(tree, value, path?) {
         configurable: true,
         value: createObjectProxy(tree, value, path),
       })
+
       return value[tree.PROXY]
     } else if (Array.isArray(value)) {
       Object.defineProperty(value, tree.PROXY, {

packages/overmind-website/api/pipe.md

@@ -57,6 +57,13 @@ The pipe is an operator in itself. Use it to compose other operators and pipes.
 h(Example, { name: "api/pipe_pipe" })
 ```
 
+## run
+This operator is useful to run effects. It will just pass the current value a long.
+
+```marksy
+h(Example, { name: "api/pipe_run" })
+```
+
 ## wait
 Hold execution for set time.