Options
All
  • Public
  • Public/Protected
  • All
Menu

use-fetch

styled with prettier Build codecov dependencies Status

Wrapper library around @nutgaard/use-async which simplifies doing fetch-request.

Installation

npm install @nutgaard/use-fetch --save

Usage

The library exposes one hook useFetch, the cache, and three utility-functions from @nutgaard/use-async to help use the result (isPending, hasData and hasError).

`typescript jsx import React from 'react'; import useFetch, { isPending, hasError } from '@nutgaard/use-fetch';

function LoadingComponent() { const result = useFetch('http://dummy.io');

if (isPending(result)) {
  return <Spinner />;
} else if (hasError(result)) {
  return <Error />
} 

return <pre>{result.data}</pre>

}


**Working with the cache:**
```typescript jsx
import { cache, createCacheKey } from '@nutgaard/use-fetch';

const options: RequestInit = { credentials: 'include' };

export function prefetch(url: string) {
    const cachekey = createCacheKey(url, options);
    cache.fetch(cachekey, url, options);
}

export function putIntoCache(url: string, value: any) {
    const cachekey = createCacheKey(url, options);
    cache.put(cachekey, Promise.resolve(new Response(JSON.stringify(value))));
}

export function removeFromCache(url: string) {
    const cachekey = createCacheKey(url, options);
    cache.remove(cachekey);
}

useFetch API

Argument Type Optional Default
url string No -
option RequestInit Yes undefined
config Config Yes { lazy: false, cacheKey: undefined }

The library will immediately perform fetch(url, option) when run, making sure to check its cache to avoid loading the same data more then once.

If lazy is set to true it will not fetch data until result.rerun() is called. cacheKey may be used to override the cachekey used to index data, if left as undefined a key is generated based on url and option.

Types

Full documentation of types can be seen here, or in the 80-ish lines of code.

Credits

Made using the awesome typescript library starter

Index

Type aliases

FetchResult

FetchResult: object & AsyncResult<TYPE>

Variables

Let cacheKeyCreator

cacheKeyCreator: createCacheKey = createCacheKey

Const globaleFetchCache

globaleFetchCache: FetchCache = new FetchCache()

Functions

createCacheKey

  • createCacheKey(url: string, option?: RequestInit): string
  • Parameters

    • url: string
    • Optional option: RequestInit

    Returns string

handleResponse

  • handleResponse<TYPE>(response: Promise<Response>, setStatusCode: function, cacheKey: string): Promise<TYPE>
  • Type parameters

    • TYPE

    Parameters

    • response: Promise<Response>
    • setStatusCode: function
        • (status: number): void
        • Parameters

          • status: number

          Returns void

    • cacheKey: string

    Returns Promise<TYPE>

setCacheKeyGenerator

useFetch

  • useFetch<TYPE>(url: string, option?: RequestInit, config?: Config): FetchResult<TYPE>
  • Type parameters

    • TYPE

    Parameters

    • url: string
    • Optional option: RequestInit
    • Default value config: Config = {lazy: false,cacheKey: undefined}

    Returns FetchResult<TYPE>

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc