TypeScript Module.createAction方法代码示例

    outputItems: [],
    name: null,
    message: null,
    itemCount: undefined,
    count: 0,
  };
};

const module = new Module({
  initialState: initialState(),
  actionExtraData: () => ({ when: new Date() }),
});

export const setJobType = module.createAction({
  type: 'crafting/job/set-job',
  action: (jobType: string) => ({ jobType }),
  reducer: (s, a) => ({ type: a.jobType }),
});

export const setStatus = module.createAction({
  type: 'crafting/job/set-status',
  action: (status: string) => ({ status }),
  reducer: (s, a) => ({ status: a.status }),
});

export const setCount = module.createAction({
  type: 'crafting/job/set-count',
  action: (count: number) => ({ count }),
  reducer: (s, a) => ({ count: a.count || 0 }),
});

    const screen: Size = { width: window.innerWidth, height: window.innerHeight };
    return {
      ...state,
      lastScreenSize: screen,
    };
  },
});

/////////////////////////////////
// Actions
/////////////////////////////////

// NO OP -- #TODO: do I really need this?
const init = module.createAction({
  type: 'layout/INITIALIZE',
  action: () => null,
  reducer: s => s,
});

// Async init - allows window onresize to dispatch actions
export function initialize() {
  return (dispatch: (action: any) => any) => {
    dispatch(init());
    window.onresize = () => {
      if (window.innerWidth >= 640 && window.innerHeight >= 480) {
        dispatch(resize());
      }
    };

    // hook up to event triggers
    game.on('navigate', (name: string) => {

  SET_FILTER_BUTTONS: 'charactersheets-inventory-SET_FILTER_BUTTONS',
};

export interface FilterButtonState {
  filterButtons: InventoryFilterButton[];
}

export function getInitialState() {
  const initialState: FilterButtonState = {
    filterButtons: defaultFilterButtonIcons,
  };
  return initialState;
}

export const module = new Module({
  initialState: getInitialState(),
});

export const setFilterButtons = module.createAction({
  type: types.SET_FILTER_BUTTONS,
  action: (action: { filterButtons: InventoryFilterButton[] }) => action,
  reducer: (state, action) => {
    const filterButtons = action.filterButtons;
    return {
      filterButtons,
    };
  },
});

export default module.createReducer();

// Initialize patcher signalr connections
export const initialize = module.createAction({
  type: 'controller/initialize',
  action: () => {
    Object.defineProperty(client, 'accessToken', { get() { return patcher.getAccessToken(); } });
    return (dispatch: (action: ControllerAction) => any) => {
      dispatch(reset() as ControllerAction);
      dispatch(initSignalR() as ControllerAction);
      registerPatcherHubEvents(dispatch);
      dispatch(getChannels());
      // update channel info on a timer...
      if (channelUpdateInterval === null) {
        channelUpdateInterval = setInterval(() => dispatch(getChannels()), 500);
      }

      try {
        // Connect to patcher api server signalr patcher hub
        startPatcherSignalR(dispatch).then((ok) => {
          if (ok) {
            // Connect to other server's signalr pathcer hubs.
            startOtherSignalR(dispatch);
          }
        });
      } catch (e) {
        console.error(e);
        dispatch(initSignalRFailed() as ControllerAction);
      }
    };
  },
});

  };
  return initialState;
}

export const module = new Module({
  initialState: getInitialState(),
});

export const onSelectBane = module.createAction({
  type: 'cu-character-creation/banes-and-boons/ON_SELECT_BANE',
  action: (action: { bane: BanesAndBoonsInfo }) => action,
  reducer: (state, action) => {
    const addedBanes = state.addedBanes;
    const traits = state.traits;
    addedBanes[action.bane.id] = action.bane.id;
    traits[action.bane.id] = { ...action.bane, selected: true };
    return {
      traits,
      addedBanes,
      totalPoints: state.totalPoints + action.bane.points,
    };
  },
});

export const onSelectBoon = module.createAction({
  type: 'cu-character-creation/banes-and-boons/ON_SELECT_BOON',
  action: (action: { boon: BanesAndBoonsInfo }) => action,
  reducer: (state, action) => {
    const addedBoons = state.addedBoons;
    const traits = state.traits;
    addedBoons[action.boon.id] = action.boon.id;

  stack?: InventoryItem.Fragment[];
}

export interface InventoryState {
  itemSlots: ItemSlot[];
}

export function getInitialState() {
  const initialState: InventoryState = {
    itemSlots: [],
  };
  return initialState;
}

export const module = new Module({
  initialState: getInitialState(),
});

export const setItemSlots = module.createAction({
  type: types.SET_ITEM_SLOTS,
  action: (action: { itemSlots: ItemSlot[] }) => action,
  reducer: (state, action) => {
    const { itemSlots } = action;
    return {
      itemSlots,
    };
  },
});

export default module.createReducer();

    const screen: Size = { width: window.innerWidth, height: window.innerHeight };
    return {
      ...state,
      lastScreenSize: screen
    }
  }
});

/////////////////////////////////
// Actions
/////////////////////////////////

// NO OP -- #TODO: do I really need this?
const init = module.createAction({
  type: 'layout/INITIALIZE',
  action: () => null,
  reducer: s => s
});

// Async init - allows window onresize to dispatch actions
export function initialize() {
  return (dispatch: (action: any) => any) => {
    dispatch(init());
    window.onresize = () => {
      if (window.innerWidth >= 640 && window.innerHeight >= 480) {
        dispatch(resize());
      }
    };
  }
}

  });
}

export const gotVoxRecipes = module.createAction({
  type: 'crafting/recipes/got-recipes',
  action: (recipeType: string, recipes: VoxRecipe[]) => ({
    recipeType,
    recipes,
  }),
  reducer: (s, a) => {
    const type = a.recipeType;
    switch (type) {
      case 'grind':
      case 'shape':
      case 'block':
      case 'make':
        const mappedVoxRecipes = mapVoxRecipesToRecipes(a.recipes);
        return { [type]: mappedVoxRecipes.sort((a, b) => a.name.localeCompare(b.name)) };
      case 'purify': {
        const mappedPurifyRecipes = mapPurifyRecipesToRecipes(a.recipes);
        return { [type]: mappedPurifyRecipes.sort((a, b) => a.name.localeCompare(b.name)) };
      }
    }
    console.error('CRAFTING: illegal recipe type ' + type);

    return {};
  },
});

export default module.createReducer();

};

const module = new Module({
  initialState: initialState(),
  actionExtraData: () => {
    return {
      when: new Date(),
    };
  },
});

export const setUIMode = module.createAction({
  type: 'crafting/ui/mode',
  action: (mode: string) => {
    return { mode };
  },
  reducer: (s, a) => {
    return { mode: a.mode };
  },
});

export const setRemaining = module.createAction({
  type: 'crafting/ui/crafting-progress',
  action: (remaining: number) => {
    return { remaining };
  },
  reducer: (s, a) => {
    return { remaining: a.remaining };
  },
});

    const screen: Size = { width: window.innerWidth, height: window.innerHeight };
    return {
      ...state,
      lastScreenSize: screen,
    };
  },
});

/////////////////////////////////
// Actions
/////////////////////////////////

// NO OP -- #TODO: do I really need this?
const init = module.createAction({
  type: 'layout/INITIALIZE',
  action: () => null,
  reducer: s => s,
});

// Async init - allows window onresize to dispatch actions
export function initialize() {
  return (dispatch: (action: any) => any) => {
    dispatch(init());
    window.onresize = () => {
      if (window.innerWidth >= 640 && window.innerHeight >= 480) {
        // dispatch(resize());
      }
    };

    // hook up to event triggers
    events.on('hudnav--navigate', (name: string) => {