TypeScript utils.merge方法代码示例

actionDefs[SERVER_UPDATE] = function serverUpdateReducer(state: ControllerState, action: ControllerAction): ControllerState {
  if (action.server.name === 'localhost') return state;
  const servers = utils.clone(state.servers);
  servers[action.server.name] = utils.merge(servers[action.server.name], webAPIServerToPatcherServer(action.server));
  return utils.merge(state, {
    servers: servers
  });
}

  reducer: (s, a) => {
    const channelServers: utils.Dictionary<PatcherServer> = {};
    const channelDict: utils.Dictionary<Channel> = {};
    for (let i = 0; i < a.channels.length; ++i) {
      const c = a.channels[i];
      // check if we have a server with a matching name to a channel, if not the channel becomes it's own 'server'.
      if (!s.servers[c.channelName]) {
        // create a server for this channel
        channelServers[c.channelName] = channelToPatcherServer(c);
      } else {
        // if it's not it's own server add to a dictionary to update servers by channel id
        channelDict[c.channelID] = c;

        // while we're here lets see if we need to update the last updated time
        if (s.servers[c.channelName].channelStatus === ChannelStatus.Updating && c.channelStatus === ChannelStatus.Ready) {
          localStorage.setItem(`channel_updated_${c.channelName}`, a.when.toLocaleString());
        }
      }
    }

    const servers = utils.clone(s.servers);
    for (const key in servers) {
      const server = servers[key];
      servers[key].channelStatus = channelDict[server.channelID] ? channelDict[server.channelID].channelStatus :
        ChannelStatus.NotInstalled;
      servers[key].lastUpdated = channelDict[server.channelID].lastUpdated || 0;
    }

    return {
      servers: utils.merge(servers, channelServers),
    };
  },

actionDefs[SERVER_UNAVAILABLE] = function serverUnavailableReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const servers = utils.clone(state.servers);
  servers[action.id].available = false;
  return utils.merge(state, {
    servers: servers
  });
}

actionDefs[ALERT_EXPIRED] = function alertExpiredReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const alerts = utils.clone(state.alerts);
  delete alerts[action.id];
  return utils.merge(state, {
    alerts: alerts
  });
}

actionDefs[ALERT_RECIEVED] = function alertRecievedReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const alerts = utils.clone(state.alerts);
  alerts[action.alert.id] = action.alert;
  return utils.merge(state, {
    alerts: alerts
  });
};

 reducer: (s, a) => {
   if (a.server.name === 'localhost') return {};
   const servers = utils.clone(s.servers);
   servers[a.server.name] = utils.merge(servers[a.server.name], webAPIServerToPatcherServer(a.server));
   return {
     servers,
   };
 },

actionDefs[CHARACTER_REMOVED] = function characterRemovedReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const characters = utils.clone(state.characters);
  delete characters[action.id];
  const servers = updateCharacterCounts(utils.clone(state.servers), characters);
  return utils.merge(state, {
    characters: characters,
    servers: servers
  });
}

actionDefs[CHARACTER_UPDATE] = function characterUpdateReducer(state: ControllerState, action: ControllerAction): ControllerState {
  const characters = utils.clone(state.characters);
  characters[action.character.id] = action.character;
  const servers = updateCharacterCounts(utils.clone(state.servers), characters);
  return utils.merge(state, {
    characters: characters,
    servers: servers
  });
}

function webAPIServerToPatcherServer(server: webAPI.servers.Server): PatcherServer {

  const channels = patcher.getAllChannels();
  const channelIndex = utils.findIndexWhere(channels, c => c.channelID === server.channelID);
  const channel = channels[channelIndex];

  return utils.merge({
    name: server.name,
    available: server.playerMaximum > 0,
    type: ServerType.CUGAME,
    channelStatus: channel ? channel.channelStatus : ChannelStatus.NotInstalled,
  }, server);
}

actionDefs[GET_CHANNELS] = function getChannelsReducer(state: ControllerState, action: ControllerAction): ControllerState {

  const channelServers: utils.Dictionary<PatcherServer> = {};
  const channelDict: utils.Dictionary<Channel> = {};
  for (let i = 0; i < action.channels.length; ++i) {
    const c = action.channels[i];
    // check if we have a server with a matching name to a channel, if not the channel becomes it's own 'server'.
    if (!state.servers[c.channelName]) {
      // create a server for this channel
      channelServers[c.channelName] = channelToPatcherServer(c);
      let lastUpdated = localStorage.getItem(`channel_updated_${c.channelName}`);
      if (lastUpdated) {
        channelServers[c.channelName].lastUpdated = lastUpdated;
      }
    } else {
      // if it's not it's own server add to a dictionary to update servers by channel id
      channelDict[c.channelID] = c;

      // while we're here lets see if we need to update the last updated time
      if (state.servers[c.channelName].channelStatus === ChannelStatus.Updating && c.channelStatus === ChannelStatus.Ready) {
        localStorage.setItem(`channel_updated_${c.channelName}`, action.when.toLocaleString());
      }
    }
  }

  const servers = utils.clone(state.servers);
  for (const server in servers) {
    var s = servers[server];
    servers[server].channelStatus = channelDict[s.channelID] ? channelDict[s.channelID].channelStatus : ChannelStatus.NotInstalled;
    servers[server].lastUpdated = channelDict[s.channelID] ? localStorage.getItem(`channel_updated_${channelDict[s.channelID].channelName}`) : undefined;
  }
  
  return utils.merge(state, {
    servers: utils.merge(servers, channelServers)
  });
}