@/store#IRootState TypeScript Examples

mapState = (state: IRootState) => {
  const { cpuStat } = state.machine;
  const { cpuBaseLine } = state.setting;
  const { aliasConfig } = state.app;
  return {
    baseLine: cpuBaseLine,
    data: getDataByType({
      data: cpuStat,
      type: 'all',
      name: 'instance',
      aliasConfig,
    }),
    valueType: VALUE_TYPE.percentage,
    loading: !!state.loading.effects.machine.asyncGetCPUStatByRange,
  };
}

mapState = (state: IRootState) => {
  const { diskSizeStat, diskStat } = state.machine;
  const { aliasConfig } = state.app;

  return {
    // According to type, only the detail increases total
    diskUsageDetail: diskStat
      .filter(item => item.metric.instance !== 'total')
      .map((instance, idx) => {
        const latestValues = _.last(instance.values);
        let size = 0;
        if (diskSizeStat[idx]) {
          size = Number(diskSizeStat[idx].value[1]);
        }
        const name = instance.metric.instance;
        return {
          size,
          type: aliasConfig[name] || name,
          value: latestValues ? Number(latestValues[1]) : 0,
        };
      }),
  };
}

mapState = (state: IRootState) => {
  const { loadStat } = state.machine;
  const { loadBaseLine } = state.setting;
  const { aliasConfig } = state.app;
  return {
    baseLine: loadBaseLine,
    data: getDataByType({
      data: loadStat,
      type: 'all',
      name: 'instance',
      aliasConfig,
    }),
    valueType: VALUE_TYPE.number,
    loading: !!state.loading.effects.machine.asyncGetLoadByRange,
  };
}

mapState = (state: IRootState) => {
  const { memoryStat, memorySizeStat } = state.machine;
  const { memoryBaseLine } = state.setting;
  const { aliasConfig } = state.app;
  return {
    data: getDataByType({
      data: memoryStat,
      type: 'all',
      name: 'instance',
      aliasConfig,
    }),
    sizes: memorySizeStat,
    baseLine: memoryBaseLine,
    valueType: VALUE_TYPE.percentage,
    loading:
      !!state.loading.effects.machine.asyncGetMemorySizeStat &&
      !!state.loading.effects.machine.asyncGetMemoryStatByRange,
  };
}

mapState = (state: IRootState) => {
  const { networkInStat } = state.machine;
  const { networkInBaseLine } = state.setting;
  const { aliasConfig } = state.app;
  return {
    baseLine: networkInBaseLine,
    data: getDataByType({
      data: networkInStat,
      type: 'all',
      name: 'instance',
      aliasConfig,
    }),
    valueType: VALUE_TYPE.byteSecondNet,
    loading: !!state.loading.effects.machine.asyncGetNetworkStatByRange,
  };
}

mapState = (state: IRootState) => {
  const { networkOutStat } = state.machine;
  const { networkOutBaseLine } = state.setting;
  const { aliasConfig } = state.app;
  return {
    baseLine: networkOutBaseLine,
    data: getDataByType({
      data: networkOutStat,
      type: 'all',
      name: 'instance',
      aliasConfig,
    }),
    valueType: VALUE_TYPE.byteSecondNet,
    loading: !!state.loading.effects.machine.asyncGetNetworkStatByRange,
  };
}

mapState = (state: IRootState) => ({
  spaces: state.nebula.spaces,
  loading: state.loading.models.nebula,
  currentSpace: state.nebula.currentSpace,
})

mapState = (state: IRootState) => ({
  type: 'network',
  dataSource: state.machine.networkStat,
  metricOptions: SUPPORT_METRICS.network,
  loading: state.loading.effects.machine.asyncGetNetworkStatByRange,
})

mapState = (state: IRootState) => ({
  aliasConfig: state.app.aliasConfig,
  serviceMetric: state.serviceMetric,
  spaces: state.nebula.spaces,
})

mapState = (state: IRootState) => ({
  loading: state.loading.models.service,
  aliasConfig: state.app.aliasConfig,
  serviceMetric: state.serviceMetric,
})

mapState = (state: IRootState) => ({
  aliasConfig: state.app.aliasConfig,
})

mapState = (state: IRootState) => ({
  panelConfig: state.service.panelConfig,
  aliasConfig: state.app.aliasConfig,
  serviceMetric: state.serviceMetric,
})

mapState = (state: IRootState) => ({
  loading: state.loading.effects.nebula.asyncGetServiceConfigs,
  configs: state.nebula.configs,
})

mapState = (state: IRootState) => ({
  loading: state.loading.effects.nebula.asyncGetJobs,
  jobs: state.nebula.jobs,
  version: state.nebula.version,
  spaces: state.nebula.spaces,
  currentSpace: state.nebula.currentSpace,
})

mapState = (state: IRootState) => ({
  loading: state.loading.effects.nebula.asyncGetParts,
  spaces: state.nebula.spaces,
  parts: state.nebula.parts,
  currentSpace: state.nebula.currentSpace,
})

mapState = (state: IRootState) => ({
  loading: state.loading.effects.nebula.asyncGetServices,
  services: state.nebula.services,
})

mapState = (state: IRootState) => ({
  loading: state.loading.models.service,
})

mapState = (state: IRootState) => ({
  appVersion: state.app.version,
  nebluaVersion: state.nebula.version,
})

mapState = (state: IRootState) => ({
  cpuBaseLine: state.setting.cpuBaseLine,
  memoryBaseLine: state.setting.memoryBaseLine,
  networkOutBaseLine: state.setting.networkOutBaseLine,
  networkInBaseLine: state.setting.networkInBaseLine,
  loadBaseLine: state.setting.loadBaseLine,
})

mapState = (state: IRootState) => ({
  aliasConfig: state.app.aliasConfig,
  cpuBaseLine: state.setting.cpuBaseLine,
  memoryBaseLine: state.setting.memoryBaseLine,
  loadBaseLine: state.setting.loadBaseLine,
  diskBaseLine: state.setting.diskBaseLine,
  networkBaseLine: state.setting.networkBaseLine,
})

mapState = (state: IRootState) => ({
  username: state.app.username,
})

mapState = (state: IRootState) => ({
  type: 'memory',
  dataSource: state.machine.memoryStat,
  metricOptions: SUPPORT_METRICS.memory,
  loading: state.loading.effects.machine.asyncGetMemoryStatByRange,
})

mapState = (state: IRootState) => ({
  type: 'load',
  dataSource: state.machine.loadStat,
  metricOptions: SUPPORT_METRICS.load,
  loading: state.loading.effects.machine.asyncGetLoadByRange,
})

mapState = (state: IRootState) => ({
  type: 'disk',
  dataSource: state.machine.diskStat,
  metricOptions: SUPPORT_METRICS.disk,
  loading: state.loading.effects.machine.asyncGetDiskStatByRange,
})

mapState = (state: IRootState) => ({
  type: 'cpu',
  dataSource: state.machine.cpuStat,
  metricOptions: SUPPORT_METRICS.cpu,
  loading: !!state.loading.effects.machine.asyncGetCPUStatByRange,
})

mapState = (state: IRootState) => ({
  appVersion: state.app.version,
  connection: state.app.connection,
})

mapState = (state: IRootState) => ({
  loading: state.loading.effects.nebula.asyncGetHostsInfo,
})