TypeScript fluxx.LocalStore函数代码示例

export const loginStore = () => LocalStore(initialState, on => {
  on(actions.updateEmail, (state, value) => {
    return Object.assign({}, state, {
      email: updateFieldValidation(state.email, value, validateEmail(value))
    })
  })

  on(actions.updatePassword, (state, value) => {
    return Object.assign({}, state, {
      password: updateFieldValidation(state.password, value, validatePassword(value))
    })
  })

  on(actions.updateErrors, (state, value) => {
    return Object.assign({}, state, {errors: value})
  })

  on(actions.closeErrors, (state) => {
    return Object.assign({}, state, {errors: null})
  })

  on(actions.success, (state) => {
    return Object.assign({}, state, {step: "success"})
  })
})

export const resetPasswordStore = () => LocalStore(initialState, on => {
  on(actions.updatePassword, (state, value) => {
    return Object.assign({}, state, {
      password: updateFieldValidation(state.password, value, validatePassword(value)),
      password2: updateUnchangedFieldValidation(state.password2, state.password2.value, validatePassword2(value, state.password2.value))
    })
  })

  on(actions.updatePassword2, (state, value) => {
    return Object.assign({}, state, {
      password2: updateFieldValidation(state.password2, value, validatePassword2(state.password.value, value))
    })
  })

  on(actions.updateErrors, (state, value) => {
    return Object.assign({}, state, {errors: value})
  })

  on(actions.closeErrors, (state) => {
    return Object.assign({}, state, {errors: null})
  })

  on(actions.success, (state) => {
    return Object.assign({}, state, {step: "success"})
  })
})

export const showListStore = () => LocalStore(initialState, on => {
  on(actions.updateList, (state, shows) => {
    return copy(state, {
      nextShows: shows.filter(_ => _.plays && _.plays.length),
      previousShows: shows.filter(_ => !(_.plays && _.plays.length))
    })
  })
})

export const playPageStore = () => LocalStore(initialState, on => {
  on(actions.initialize, (state, {company, show, play, playsFromShow}) => {
    return copy(state, {
      company, show, play,
      otherPlays: arrays.sort(playsFromShow.filter(p => p.id !== play.id), (p1, p2) => p1.date.getTime() - p2.date.getTime())
    })
  })
})

export const companyListStore = () => LocalStore(initialState, on => {
  on(actions.updateList, (state, companies) => {
    return copy(state, {
      vepCompanies: arrays.sort(companies.filter(_ => _.isVep), compareCompanies),
      notVepCompanies: arrays.sort(companies.filter(_ => !_.isVep), compareCompanies)
    })
  })
})

export const adhesionListStore = () => LocalStore(initialState, on => {
  on(actions.initialize, (state, {period, adhesions}) => {
    return copy(state, {
      period: period,
      acceptedAdhesions: adhesions.filter(_ => _.accepted),
      notAcceptedAdhesions: adhesions.filter(_ => !_.accepted)
    })
  })
})

export const navigationStore = () => LocalStore(initialState, on => {
  on(actions.initialize, (state, {shows, plays, pages}) => {
    return copy(state, {shows, plays, pages})
  })

  on(actions.updateSession, (state, session) => {
    return copy(state, {session})
  })
})

export const requestAdhesionFormStore = () => LocalStore(initialState, on => {
  on(actions.initialize, (state, {acceptedPeriods}) => {
    return copy(state, {step: "form", acceptedPeriods})
  })

  on(actions.updatePeriod, (state, value) => {
    return copy(state, {
      period: updateFieldValidation(state.period, value, Valid(value))
    })
  })

  on(actions.addMember, (state) => {
    const newMembers = arrays.append(state.members.value, defaultMember)
    return copy(state, {
      members: updateFieldValidation(state.members, newMembers, validateMembers(newMembers))
    })
  })

  on(actions.removeMember, (state, index) => {
    const newMembers = arrays.remove(state.members.value, index)
    return copy(state, {
      members: updateFieldValidation(state.members, newMembers, validateMembers(newMembers))
    })
  })

  on(actions.updateMemberFirstName, (state, {index, value}) =>
    updateMember(state, index, member => copy(member, {
      firstName: updateFieldValidation(member.firstName, value, validateNonBlank(value))
    }))
  )

  on(actions.updateMemberLastName, (state, {index, value}) =>
    updateMember(state, index, member => copy(member, {
      lastName: updateFieldValidation(member.lastName, value, validateNonBlank(value))
    }))
  )

  on(actions.updateMemberBirthday, (state, {index, value}) =>
    updateMember(state, index, member => copy(member, {
      birthday: updateFieldValidation(member.birthday, value, validatePassed(value))
    }))
  )

  on(actions.updateMemberActivity, (state, {index, value}) =>
    updateMember(state, index, member => copy(member, {
      activity: updateFieldValidation(member.activity, value, Valid(value))
    }))
  )

  on(actions.closeErrors, (state) => {
    return copy(state, {errors: null})
  })

  on(actions.success, (state) => {
    return copy(state, {step: "success"})
  })
})

export const periodAdhesionListStore = () => LocalStore(initialState, on => {
  on(actions.updateList, (state, periodsAdhesion) => {
    return copy(state, {
      currentPeriodsAdhesion: periodsAdhesion.filter(_ => isCurrent(_.period)),
      futurePeriodsAdhesion: periodsAdhesion.filter(_ => isFuture(_.period)),
      passedPeriodsAdhesion: periodsAdhesion.filter(_ => isPassed(_.period))
    })
  })
})

export const profilePageStore = () => LocalStore(initialState, on => {
  on(actions.initialize, (state, {profile, adhesions}) => {
    return copy(state, {
      profile: profile,
      acceptedAdhesions: adhesions.filter(_ => _.accepted),
      notAcceptedAdhesions: adhesions.filter(_ => !_.accepted)
    })
  })
})