TypeScript actions.isType函数代码示例

export const sendActionToServer = (action: Action<any>):Promise<any> => {
  const pathname = mockable(() => location.pathname)
  const requester = mockable(() => jsonRequest)
  const url_token = pathname.split('/')[3]

  if (isType(action, createStickyAction)) {
    return requester({uri: '/api/stickies', method: 'POST', body: combine(action.payload, {url_token})})
  }

  if (isType(action, interactionFinishedStickyAction)) {
    const sticky = getState().stickies.get(action.payload.uuid)
    const command = {
      x: sticky.x,
      y: sticky.y,
      uuid: action.payload.uuid,
      url_token,
      body: sticky.body
    }
    
    return requester({uri: '/api/stickies', method: 'PUT', body: command})
  }

  console.error('Warning: Unhandled persistence action: ', action.type)
  return Promise.resolve()
}

export const boardReducers = (state: Board = {initialLoadPending: true, name: '', notFound: false}, action: Action<any>): Board => {
  if (isType(action, boardLoadedAction)) {
    return {initialLoadPending: false, name: action.payload.name, notFound: false}
  }
  
  if (isType(action, boardNotFoundAction)) {
    return {initialLoadPending: false, name: '', notFound: true}
  }
  
  return state
}

export const persistenceQueueReducers = (state: PersistenceQueue = Immutable.List<QueueItem>(), action: Action<any>): PersistenceQueue => {
  if (isType(action, createStickyAction) || isType(action, interactionFinishedStickyAction)) {
    return state.push(makeQueueItem(action))   
  }

  if(isType(action, persistenceQueueSuccessAction)) {
    const queueUuid = action.payload.queueUuid
    return state.filter((value) => typeof value !== 'undefined' && value.queueUuid != queueUuid).toList()
  }
  
  return state
}

export const stickiesReducers = (state: Stickies = Immutable.Map<string, Sticky>(), action: Action<any>): Stickies => {
  const getUuuid = (sticky:Sticky) => state.keyOf(sticky)
  
  if (isType(action, createStickyAction) || isType(action, loadStickyFromServerAction)) {
    const sticky = {
      x: action.payload.x,
      y: action.payload.y,
      editing: false,
      body: action.payload.body,
      z: state.size + 1
    }
    return state.set(action.payload.uuid, sticky)
  }
   
  if (isType(action, updateStickyAction)) {
    const sticky = modifySticky(state.get(action.payload.uuid), {
      x: action.payload.x,
      y: action.payload.y,
      editing: action.payload.editing,
      body: action.payload.body
    })
    return state.map(markNotEdited).toMap().set(action.payload.uuid, sticky)
  }
  
  if (isType(action, moveStickyToTopAction)) {
    const existingSticky = state.get(action.payload.uuid)
    const foregroundSticky = modifySticky(existingSticky, {z: state.size})
   
    const otherUuids = state.keySeq().toArray().filter((uuid) => uuid !== action.payload.uuid)
    const sorted = otherUuids.map((uuid) => ({uuid, sticky: state.get(uuid)}))
        .sort((a, b) => a.sticky.z - b.sticky.z)
   
    
    const assignZ = (sticky:Sticky) => modifySticky(sticky, {z: 1 + lodash.findIndex(sorted, (el) => el.uuid === getUuuid(sticky))})
    
    return state.map(assignZ).toMap().set(action.payload.uuid, foregroundSticky)
  }
  
  if (isType(action, removeStickyAction)) {
    return state.filter((value, key) => key != action.payload.uuid).toMap()
  }
  
  return state
}

export const canvasReducers = (state: Canvas = {x: 0, y: 0}, action: Action<any>): Canvas => {
  if (isType(action, moveCanvasPositionAction)) {
    return {x: state.x + action.payload.x, y: state.y + action.payload.y}
  }
  return state
}