TypeScript RefreshPicker.isLive函数代码示例

    mapper: (state, action): ExploreItemState => {
      const { queryIntervals, refreshInterval } = state;
      const { data } = action.payload;
      const live = isLive(refreshInterval);

      if (!live) {
        return state;
      }

      const newResults = seriesDataToLogsModel([data], queryIntervals.intervalMs);
      const rowsInState = sortLogsResult(state.logsResult, state.refreshInterval).rows;

      const processedRows = [];
      for (const row of rowsInState) {
        processedRows.push({ ...row, fresh: false });
      }
      for (const row of newResults.rows) {
        processedRows.push({ ...row, fresh: true });
      }

      const rows = processedRows.slice(processedRows.length - 1000, 1000);

      const logsResult: LogsModel = state.logsResult ? { ...state.logsResult, rows } : { hasUniqueLabels: false, rows };

      return {
        ...state,
        logsResult,
      };
    },

    mapper: (state, action): ExploreItemState => {
      const { queryIntervals, refreshInterval } = state;
      const { result, resultType, latency } = action.payload;
      const results = calculateResultsFromQueryTransactions(result, resultType, queryIntervals.intervalMs);
      const live = isLive(refreshInterval);

      if (live) {
        return state;
      }

      return {
        ...state,
        graphResult: resultType === 'Graph' ? results.graphResult : state.graphResult,
        tableResult: resultType === 'Table' ? results.tableResult : state.tableResult,
        logsResult:
          resultType === 'Logs'
            ? sortLogsResult(results.logsResult, refreshInterval)
            : sortLogsResult(state.logsResult, refreshInterval),
        latency,
        graphIsLoading: live ? true : false,
        logIsLoading: live ? true : false,
        tableIsLoading: live ? true : false,
        showingStartPage: false,
        update: makeInitialUpdateState(),
      };
    },

export const sortLogsResult = (logsResult: LogsModel, refreshInterval: string) => {
  const rows = logsResult ? logsResult.rows : [];
  const live = isLive(refreshInterval);
  live ? rows.sort(sortInAscendingOrder) : rows.sort(sortInDescendingOrder);
  const result: LogsModel = logsResult ? { ...logsResult, rows } : { hasUniqueLabels: false, rows };

  return result;
};

              filter(action => {
                if (action.type === resetExploreAction.type) {
                  return true; // stops all subscriptions if user navigates away
                }

                if (action.type === updateDatasourceInstanceAction.type && action.payload.exploreId === exploreId) {
                  return true; // stops subscriptions if user changes data source
                }

                if (action.type === changeRefreshIntervalAction.type && action.payload.exploreId === exploreId) {
                  return !isLive(action.payload.refreshInterval); // stops subscriptions if user changes refresh interval away from 'Live'
                }

                if (action.type === clearQueriesAction.type && action.payload.exploreId === exploreId) {
                  return true; // stops subscriptions if user clears all queries
                }

                return action.payload.exploreId === exploreId && action.payload.refId === refId;
              }),

    mergeMap((action: ActionOf<StartSubscriptionsPayload>) => {
      const { exploreId, dataReceivedActionCreator } = action.payload;
      const { datasourceInstance, queries, refreshInterval } = state$.value.explore[exploreId];

      if (!datasourceInstance || !datasourceInstance.convertToStreamTargets) {
        return NEVER; //do nothing if datasource does not support streaming
      }

      if (!refreshInterval || !isLive(refreshInterval)) {
        return NEVER; //do nothing if refresh interval is not 'LIVE'
      }

      const request: any = { targets: queries };
      return datasourceInstance.convertToStreamTargets(request).map(target =>
        startSubscriptionAction({
          url: convertToWebSocketUrl(target.url),
          refId: target.refId,
          exploreId,
          dataReceivedActionCreator,
        })
      );
    })