@taro-hooks/use-request/es/plugins/useCachePlugin.js

useRequest hook for Taro

import { useRef } from '@taro-hooks/core';
import { useCreation, useUnmount } from '@taro-hooks/ahooks';
import * as cache from '../utils/cache';
import * as cachePromise from '../utils/cachePromise';
import * as cacheSubscribe from '../utils/cacheSubscribe';
var useCachePlugin = function useCachePlugin(fetchInstance, _ref) {
  var cacheKey = _ref.cacheKey,
    _ref$cacheTime = _ref.cacheTime,
    cacheTime = _ref$cacheTime === void 0 ? 5 * 60 * 1000 : _ref$cacheTime,
    _ref$staleTime = _ref.staleTime,
    staleTime = _ref$staleTime === void 0 ? 0 : _ref$staleTime,
    customSetCache = _ref.setCache,
    customGetCache = _ref.getCache;
  var unSubscribeRef = useRef();
  var currentPromiseRef = useRef();
  var _setCache = function _setCache(key, cachedData) {
    if (customSetCache) {
      customSetCache(cachedData);
    } else {
      cache.setCache(key, cacheTime, cachedData);
    }
    cacheSubscribe.trigger(key, cachedData.data);
  };
  var _getCache = function _getCache(key, params) {
    if (params === void 0) {
      params = [];
    }
    if (customGetCache) {
      return customGetCache(params);
    }
    return cache.getCache(key);
  };
  useCreation(function () {
    if (!cacheKey) {
      return;
    }
    // get data from cache when init
    var cacheData = _getCache(cacheKey);
    if (cacheData && Object.hasOwnProperty.call(cacheData, 'data')) {
      fetchInstance.state.data = cacheData.data;
      fetchInstance.state.params = cacheData.params;
      if (staleTime === -1 || new Date().getTime() - cacheData.time <= staleTime) {
        fetchInstance.state.loading = false;
      }
    }
    // subscribe same cachekey update, trigger update
    unSubscribeRef.current = cacheSubscribe.subscribe(cacheKey, function (data) {
      fetchInstance.setState({
        data: data
      });
    });
  }, []);
  useUnmount(function () {
    unSubscribeRef.current == null ? void 0 : unSubscribeRef.current();
  });
  if (!cacheKey) {
    return {};
  }
  return {
    onBefore: function onBefore(params) {
      var cacheData = _getCache(cacheKey, params);
      if (!cacheData || !Object.hasOwnProperty.call(cacheData, 'data')) {
        return {};
      }
      // If the data is fresh, stop request
      if (staleTime === -1 || new Date().getTime() - cacheData.time <= staleTime) {
        return {
          loading: false,
          data: cacheData == null ? void 0 : cacheData.data,
          returnNow: true
        };
      } else {
        // If the data is stale, return data, and request continue
        return {
          data: cacheData == null ? void 0 : cacheData.data
        };
      }
    },
    onRequest: function onRequest(service, args) {
      var servicePromise = cachePromise.getCachePromise(cacheKey);
      // If has servicePromise, and is not trigger by self, then use it
      if (servicePromise && servicePromise !== currentPromiseRef.current) {
        return {
          servicePromise: servicePromise
        };
      }
      servicePromise = service.apply(void 0, args);
      currentPromiseRef.current = servicePromise;
      cachePromise.setCachePromise(cacheKey, servicePromise);
      return {
        servicePromise: servicePromise
      };
    },
    onSuccess: function onSuccess(data, params) {
      if (cacheKey) {
        // cancel subscribe, avoid trgger self
        unSubscribeRef.current == null ? void 0 : unSubscribeRef.current();
        _setCache(cacheKey, {
          data: data,
          params: params,
          time: new Date().getTime()
        });
        // resubscribe
        unSubscribeRef.current = cacheSubscribe.subscribe(cacheKey, function (d) {
          fetchInstance.setState({
            data: d
          });
        });
      }
    },
    onMutate: function onMutate(data) {
      if (cacheKey) {
        // cancel subscribe, avoid trgger self
        unSubscribeRef.current == null ? void 0 : unSubscribeRef.current();
        _setCache(cacheKey, {
          data: data,
          params: fetchInstance.state.params,
          time: new Date().getTime()
        });
        // resubscribe
        unSubscribeRef.current = cacheSubscribe.subscribe(cacheKey, function (d) {
          fetchInstance.setState({
            data: d
          });
        });
      }
    }
  };
};
export default useCachePlugin;