@data-client/react/legacy/hooks/useFetch.native.js

Async State Management without the Management. REST, GraphQL, SSE, Websockets, Fetch

import { ExpiryStatus } from '@data-client/core';
import { useMemo } from 'react';
import { InteractionManager } from 'react-native';
import useCacheState from './useCacheState.js';
import useController from './useController.js';
import useFocusEffect from './useFocusEffect.native.js';

/**
 * Request a resource if it is not in cache.
 * @see https://dataclient.io/docs/api/useFetch
 */

export default function useFetch(endpoint, ...args) {
  const state = useCacheState();
  const controller = useController();
  const key = args[0] !== null ? endpoint.key(...args) : '';
  const cacheResults = key && state.endpoints[key];
  const meta = state.meta[key];

  // Compute denormalized value
  const {
    expiryStatus,
    expiresAt
  } = useMemo(() => {
    return controller.getResponseMeta(endpoint, ...args, state);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [cacheResults, state.indexes, state.entities, state.entityMeta, meta, key]);

  // If we are hard invalid we must fetch regardless of triggering or staleness
  const forceFetch = expiryStatus === ExpiryStatus.Invalid;
  const maybePromise = useMemo(() => {
    // null params mean don't do anything
    if (Date.now() <= expiresAt && !forceFetch || !key) return;
    // if args is [null], we won't get to this line
    return controller.fetch(endpoint, ...args);
    // we need to check against serialized params, since params can change frequently
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [expiresAt, key, forceFetch, state.lastReset]);
  useFocusEffect(() => {
    // revalidating non-suspending data is low priority, so make sure it doesn't stutter animations
    const task = InteractionManager.runAfterInteractions(() => {
      if (Date.now() > expiresAt && key) {
        controller.fetch(endpoint, ...args);
      }
    });
    return () => task.cancel();
  }, []);
  return maybePromise;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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