Simplified typing

Dear Overminders!

I have one thing I really want to do and that is to clean up and simplify the typing of Overmind. It was a long process figuring out how to do it and with acquired knowledge through all this work and later projects I would like to do this:

import { IContext } from 'overmind'

const config = { ... }

export interface Context extends IContext<{
  state: typeof config.state,
  actions: typeof config.actions,
  effects: typeof config.effects
}> {}

There will be no more implicit typing, the above is what everybody will need to do. This is how you type the different things:

const myAction = (context: Context) => {}

const myActionWithPayload = (context: Context, payload: string) => {}

// Now we support generics
const myActionWithPayload = <T extends TEvent>(context: Context, payload: T) => {}

const myOperator = map((context: Context, value: string) => {})

const state: State = {
  someDerived: derived((state: State, rootState: Context["state"]) => {})
}

And I believe that is it. This will need to be a breaking change to actually clean up the internal typing of Overmind. I was just wondering how you feel about this change, do you consider refactoring your apps to this typing too much work? 😄

[Michielnuyts]

@christianalfoni This is all coming in V28 right? Do you have a rough release date in mind?

[christianalfoni]

So a summary of what is being moved into next now is:

New typing, no more implicit typing:

import { IContext } from 'overmind'

const config = { ... }

export type Context = IContext<{
  state: typeof config.state,
  actions: typeof config.actions,
  effects: typeof config.effects
}>

Type actions:

const myAction = (context: Context) => {}

const myActionWithPayload = (context: Context, payload: string) => {}

Operator changes:

• Now an operator is interoperable with actions, meaning you can just do:

const whatever = pipe(
  (context: Context, input: string) => input.toUpperCase()
)

• Due to interoperable actions, the map, mutate and run operators has been removed. Just use plain action signature

• forEach operators has also been removed as the typing never worked there (This might come back, have to research some more)

• fork has new signature:

pipe(
  // "type" is a property on the object on the pipe
  fork('type', {
    FOO: (context: Context, event) => {
      event // Is now typed as FooEvent
    },
    BAR: (context: context, event) => {
      event // Is now typed as BarEvent
    } 
  })
)

• parallel now actually returns an array to the pipe with the results of each operator

React hooks

• useOvermind is removed in favour of explicit hooks (more efficient and cleaner)
• useState hook now has an added signature

const ItemComponent = ({ id }) => {
  // The state you access within the callback is not tracked,
  // only the result and further access is tracked. Meaning this
  // component will only track the item, not changes to "items"
  const item = useAppState(state => state.items[id])
}