@selkirk-systems/fetch 1.2.1 → 1.4.0

package/dist/Fetch.js

@@ -439,34 +439,87 @@ export const putJsonInCache = (cache, url, json) => {
   return cache.put(url, response);
 };
 const _caches = {};
+const _updatingCache = {};
 const DATA_METHODS = {
   "GET": null,
   "PATCH": null,
   "POST": null,
   "PUT": null
 };
-const API_REG_EXP = /p\/.+com\/(.*?)\//;
-export const getCacheNameFromUrl = url => {
-  const matchArray = url.toString().match(API_REG_EXP);
-  return matchArray && matchArray.length >= 1 ? matchArray[1] : null;
-};
 const _fetch = (url, options = {}) => {
   const cacheName = getCacheNameFromUrl(url);
+
+  //HANDLE: Service worker BS, environment is different don't cache if were in a service worker.
   if (!self || !cacheName) {
     return Fetch(url, options);
   }
   let _cache = _caches[cacheName];
-  function cacheResponse([response, isAbort]) {
+  async function cacheResponse([response, isAbort]) {
     const status = response.status.code;
     const headers = response.request.headers;
     const method = response.request.method;
     if (status >= 200 && status < 400 && headers.get('content-type') === "application/json") {
-      if (DATA_METHODS.hasOwnProperty(method) || method === "GET") {
+      if (DATA_METHODS.hasOwnProperty(method)) {
         const data = serializeData(response.data);
+
+        //HANDLE: List/Array like responses
         if (data.page && !data.items || data.items && data.items.length === 0) {
           deleteFromCache(_cache, url, response);
           return [response, isAbort];
         }
+
+        //HANDLE: Record like response
+        if (data.id) {
+          let uuid = getUUID(url.toString());
+          let matchOptions = {};
+          if (method === "POST") {
+            uuid = {
+              id: data.id,
+              shortPath: url.toString()
+            };
+          }
+
+          /**
+           * POST new records are hard, what cached list do we put the new record in? what about sort? blag. Don't have a good answer yet
+           * For now, new records will be put in the first cached entry that matches at the 0 index, this 'should' be page=0 cached entries
+           * and the records should all show  up in UI at the top. This is the most common UX for adding records to a list, 
+           * one day some how figure out a less fragile robust method.
+           * 
+           * Perhaps we should just refetch all the matched cache urls... but this could be huge and slow and network heavy...
+           */
+          await cacheFindAllLike({
+            cache: _cache,
+            url: uuid.shortPath,
+            property: "id",
+            value: data.id,
+            method: method
+          }).then(async matches => {
+            if (matches.length) {
+              const finalOptions = {
+                ...responseObjectJson
+              };
+              finalOptions.headers['Time-Cached'] = new Date().getTime();
+              await matches.forEach(async match => {
+                const items = extractDataArray(match.data);
+
+                //This is where we put the new record on the top of the cached list, even if a new network request would place it somewhere
+                // else based on sort etc.
+                if (method === "POST") {
+                  items.unshift(data);
+                } else {
+                  items[match.matchIndex] = data;
+                }
+                const responseObj = new Response(JSON.stringify(match.data), finalOptions);
+                dispatch(UPDATE_CACHE, {
+                  url: new URL(match.request.url),
+                  response: match.response
+                });
+                return _cache.put(match.request.url, responseObj);
+              });
+            }
+          });
+          return [response, isAbort];
+        }
         const finalOptions = {
           ...responseObjectJson
         };
@@ -488,9 +541,37 @@ const _fetch = (url, options = {}) => {
   }
   function cacheMatch() {
     //HANDLE: Data updates, always return fresh data
-    if (options.method && DATA_METHODS.hasOwnProperty(options.method)) {
+    if (options.skipCache || options.method && DATA_METHODS.hasOwnProperty(options.method)) {
       return Fetch(url, options).then(cacheResponse);
     }
+    const uuid = getUUID(url.toString());
+
+    //HANDLE: individual records, if we are looking for a record check cache for any array or search results with this record
+    if (uuid.id) {
+      return cacheFindLike({
+        cache: _cache,
+        url: uuid.shortPath,
+        property: "id",
+        value: uuid.id
+      }).then(match => {
+        if (match) {
+          //Behind the scenes still fetch the record and update the cache but don't make the user wait for it.
+          Fetch(url, options).then(cacheResponse);
+          const responseObj = new Response(JSON.stringify(match.match));
+          return Promise.resolve([{
+            request: null,
+            response: responseObj,
+            data: match.match,
+            status: {
+              code: 200,
+              text: '',
+              isAbort: false
+            }
+          }, false]);
+        }
+        return Fetch(url, options).then(cacheResponse);
+      });
+    }
     return _cache.match(url).then(response => {
       if (response) {
         const timeCached = response.headers.get('Time-Cached');
@@ -498,8 +579,8 @@ const _fetch = (url, options = {}) => {
           _cache.delete(url);
           return Fetch(url, options).then(cacheResponse);
         }
-        Fetch(url, options).then(cacheResponse);
         return unwrapResponseData(response).then(obj => {
+          Fetch(url, options).then(cacheResponse);
           return Promise.resolve([{
             request: null,
             response: response,
@@ -530,6 +611,119 @@ function deleteFromCache(_cache, url, response) {
     response: response
   });
 }
+function cacheFindAllLike(options) {
+  const finalOptions = {
+    ...options,
+    findAll: true
+  };
+  return cacheFindLike(finalOptions);
+}
+function cacheFindLike(options) {
+  const cache = options.cache;
+  const url = options.url;
+  const property = options.property;
+  const value = options.value;
+  const findAll = options.findAll;
+  const matchOptions = options.matchOptions;
+  const method = options.method || "GET";
+  return cache.keys().then(keys => {
+    const matchingRequests = [];
+    for (let i = 0; i < keys.length; i++) {
+      const request = keys[i];
+      if (looksLikeResultListUrl(request.url, url)) {
+        matchingRequests.push(cache.match(request, matchOptions).then(match => {
+          match._request = request;
+          return match;
+        }));
+      }
+    }
+    return Promise.all(matchingRequests).then(responses => {
+      let count = 0;
+      const ret = [];
+      const checkCache = async index => {
+        if (index >= responses.length) return ret;
+        return serializeResponse(responses[index]).then(json => {
+          const items = extractDataArray(json);
+          const response = responses[count];
+          const retObj = {
+            request: response._request,
+            response: response,
+            data: json,
+            match: json,
+            matchIndex: -1,
+            status: {
+              code: response.status,
+              text: response.statusText,
+              isAbort: false
+            }
+          };
+          if (method === "POST") {
+            return findAll ? [retObj] : retObj;
+          }
+          const matchIndex = items.findIndex(item => item[property] === value);
+          count++;
+          if (matchIndex >= 0) {
+            retObj.match = items[matchIndex];
+            retObj.matchIndex = matchIndex;
+            if (!findAll) {
+              return retObj;
+            } else {
+              ret.push(retObj);
+            }
+            return checkCache(count);
+          }
+          if (count >= responses.length) {
+            return findAll ? ret : null;
+          }
+          return checkCache(count);
+        });
+      };
+      if (!responses || !responses.length) return findAll ? ret : null;
+      return checkCache(count);
+    });
+  });
+}
+
+/**
+ * Check if request.url looks like a list result type url, if it contains a UUID it is likely not.
+ * @param {*} requestURL 
+ * @param {*} matchURL 
+ * @returns 
+ */
+function looksLikeResultListUrl(requestURL, matchURL) {
+  const uuid = getUUID(requestURL.toString());
+  return !uuid.id && requestURL.indexOf(matchURL) >= 0;
+}
+function extractDataArray(obj) {
+  for (var prop in obj._embedded) {
+    if (!obj._embedded.hasOwnProperty(prop)) continue;
+    return obj._embedded[prop];
+  }
+  return [obj];
+}
+async function serializeResponse(response) {
+  return response.text().then(data => {
+    return JSON.parse(data);
+  });
+}
+function getUUID(str) {
+  const UUID_REG_EXP = /.+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}).*?/;
+  const match = UUID_REG_EXP.exec(str);
+  let id, shortPath;
+  if (match && match[1]) {
+    id = match[1];
+    shortPath = str.split(`/${id}`)[0];
+  }
+  return {
+    id: id,
+    shortPath: shortPath
+  };
+}
+function getCacheNameFromUrl(url) {
+  const API_REG_EXP = /p\/.+com\/(.*?)\//;
+  const matchArray = url.toString().match(API_REG_EXP);
+  return matchArray && matchArray.length >= 1 ? matchArray[1] : null;
+}
 function expiredCache(timeCached) {
   const now = new Date().getTime();
   return Math.abs(now - timeCached) >= CACHED_EXPIRY_TIMESTAMP;

package/dist/index.js

@@ -1,3 +1,4 @@
 export { default as Download } from './Download';
 export { default as fetch, applyMiddleware, OnOKResponse } from './Fetch';
+export * from "./utils/FetchUtils";
 export * from "./constants/FetchConstants";

package/dist/utils/FetchUtils.js

@@ -0,0 +1,74 @@
+import Fetch from '../Fetch';
+export const createUrlParams = (params, existingParams) => {
+  //SORT the params alphabetically, very important for cache lookups as the search a params in different order will cause it to not be matched.
+  params = Object.keys(params).sort().reduce((obj, key) => {
+    obj[key] = params[key];
+    return obj;
+  }, {});
+  const searchParams = existingParams ? existingParams : new URLSearchParams();
+  for (var prop in params) {
+    if (!params.hasOwnProperty(prop) || params[prop] === undefined || params[prop] === null) continue;
+    if (Array.isArray(params[prop])) {
+      if (prop === "sort") {
+        searchParams.delete("sort");
+      }
+      for (let i = 0; i < params[prop].length; i++) {
+        const e = params[prop][i];
+        if (searchParams.has(prop) && prop !== "sort") {
+          searchParams.set(prop, e);
+        } else {
+          searchParams.append(prop, e);
+        }
+      }
+      continue;
+    }
+    if (searchParams.has(prop)) {
+      searchParams.set(prop, params[prop]);
+    } else {
+      searchParams.append(prop, params[prop]);
+    }
+  }
+  return searchParams;
+};
+export async function fetchPagedURL(url, callback, options) {
+  const finalOptions = {
+    skipCache: false,
+    ...options
+  };
+  callback = callback ? callback : () => {};
+  let ret = [];
+  const proxyUrl = url.toString().split("/p/");
+  const [response] = await Fetch(url, finalOptions);
+  const {
+    data,
+    status
+  } = response;
+  const size = new TextEncoder().encode(JSON.stringify(data)).length;
+  const kiloBytes = size / 1024;
+  const megaBytes = kiloBytes / 1024;
+  if (status.code > 299 || status.code < 200) {
+    return [response, null];
+  }
+  const results = {
+    page: data.page.number + 1,
+    totalPages: data.page.totalPages,
+    totalElements: data.page.totalElements,
+    pageSize: data.page.size,
+    kiloBytes: kiloBytes,
+    megaBytes: megaBytes
+  };
+  data.items = data._embedded[[Object.keys(data._embedded)[0]]];
+  await callback(results, data.items);
+  ret = ret.concat(data.items || []);
+  if (data._links && data._links.next) {
+    const nextUrl = new URL(`${proxyUrl[0]}/p/${data._links.next.href}`);
+    nextUrl.search = createUrlParams({}, nextUrl.searchParams);
+    const [err, nextPage] = await fetchPagedURL(nextUrl, callback, options);
+    if (err) return [err, nextPage];
+    ret = ret.concat(nextPage);
+  }
+  return [null, ret];
+}
+function timeout(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/lib/Fetch.js

@@ -576,6 +576,10 @@ export const putJsonInCache = ( cache, url, json ) => {
 
 const _caches = {};
 
+const _updatingCache = {
+
+}
+
 const DATA_METHODS = {
     "GET": null,
     "PATCH": null,
@@ -583,24 +587,20 @@ const DATA_METHODS = {
     "PUT": null
 }
 
-const API_REG_EXP = /p\/.+com\/(.*?)\//;
 
-export const getCacheNameFromUrl = ( url ) => {
-    const matchArray = url.toString().match( API_REG_EXP );
-    return matchArray && matchArray.length >= 1 ? matchArray[1] : null;
-}
 
 const _fetch = ( url, options = {} ) => {
 
     const cacheName = getCacheNameFromUrl( url );
 
+    //HANDLE: Service worker BS, environment is different don't cache if were in a service worker.
     if ( !self || !cacheName ) {
         return Fetch( url, options );
     }
 
     let _cache = _caches[cacheName];
 
-    function cacheResponse( [response, isAbort] ) {
+    async function cacheResponse( [response, isAbort] ) {
 
         const status = response.status.code;
         const headers = response.request.headers;
@@ -609,10 +609,11 @@ const _fetch = ( url, options = {} ) => {
 
         if ( status >= 200 && status < 400 && headers.get( 'content-type' ) === "application/json" ) {
 
-            if ( DATA_METHODS.hasOwnProperty( method ) || method === "GET" ) {
+            if ( DATA_METHODS.hasOwnProperty( method ) ) {
 
                 const data = serializeData( response.data );
 
+                //HANDLE: List/Array like responses
                 if ( data.page && !data.items || data.items && data.items.length === 0 ) {
 
                     deleteFromCache( _cache, url, response );
@@ -621,6 +622,65 @@ const _fetch = ( url, options = {} ) => {
 
                 }
 
+                //HANDLE: Record like response
+                if ( data.id ) {
+
+                    let uuid = getUUID( url.toString() );
+                    let matchOptions = {};
+
+                    if ( method === "POST" ) {
+
+                        uuid = {
+                            id: data.id,
+                            shortPath: url.toString()
+                        }
+
+                    }
+
+                    /**
+                     * POST new records are hard, what cached list do we put the new record in? what about sort? blag. Don't have a good answer yet
+                     * For now, new records will be put in the first cached entry that matches at the 0 index, this 'should' be page=0 cached entries
+                     * and the records should all show  up in UI at the top. This is the most common UX for adding records to a list, 
+                     * one day some how figure out a less fragile robust method.
+                     * 
+                     * Perhaps we should just refetch all the matched cache urls... but this could be huge and slow and network heavy...
+                     */
+                    await cacheFindAllLike( { cache: _cache, url: uuid.shortPath, property: "id", value: data.id, method: method } )
+                        .then( async ( matches ) => {
+
+                            if ( matches.length ) {
+
+                                const finalOptions = { ...responseObjectJson };
+                                finalOptions.headers['Time-Cached'] = new Date().getTime();
+
+                                await matches.forEach( async match => {
+
+                                    const items = extractDataArray( match.data );
+
+                                    //This is where we put the new record on the top of the cached list, even if a new network request would place it somewhere
+                                    // else based on sort etc.
+                                    if ( method === "POST" ) {
+                                        items.unshift( data );
+                                    }
+                                    else {
+                                        items[match.matchIndex] = data;
+                                    }
+
+                                    const responseObj = new Response( JSON.stringify( match.data ), finalOptions );
+
+                                    dispatch( UPDATE_CACHE, { url: new URL( match.request.url ), response: match.response } );
+
+                                    return _cache.put( match.request.url, responseObj );
+
+                                } )
+
+                            }
+                        } )
+
+                    return [response, isAbort];
+
+                }
+
                 const finalOptions = { ...responseObjectJson };
                 finalOptions.headers['Time-Cached'] = new Date().getTime();
 
@@ -649,12 +709,45 @@ const _fetch = ( url, options = {} ) => {
     function cacheMatch() {
 
         //HANDLE: Data updates, always return fresh data
-        if ( options.method && DATA_METHODS.hasOwnProperty( options.method ) ) {
+        if ( options.skipCache || options.method && DATA_METHODS.hasOwnProperty( options.method ) ) {
 
             return Fetch( url, options ).then( cacheResponse );
 
         }
 
+        const uuid = getUUID( url.toString() );
+
+        //HANDLE: individual records, if we are looking for a record check cache for any array or search results with this record
+        if ( uuid.id ) {
+
+            return cacheFindLike( { cache: _cache, url: uuid.shortPath, property: "id", value: uuid.id } ).then( ( match ) => {
+
+                if ( match ) {
+
+                    //Behind the scenes still fetch the record and update the cache but don't make the user wait for it.
+                    Fetch( url, options ).then( cacheResponse );
+
+                    const responseObj = new Response( JSON.stringify( match.match ) );
+
+                    return Promise.resolve( [{
+                        request: null,
+                        response: responseObj,
+                        data: match.match,
+                        status: {
+                            code: 200,
+                            text: '',
+                            isAbort: false
+                        },
+                    }, false] )
+                }
+
+
+                return Fetch( url, options ).then( cacheResponse );
+
+            } )
+
+        }
+
 
         return _cache.match( url ).then( ( response ) => {
 
@@ -669,9 +762,8 @@ const _fetch = ( url, options = {} ) => {
 
                 }
 
-                Fetch( url, options ).then( cacheResponse )
-
                 return unwrapResponseData( response ).then( ( obj ) => {
+                    Fetch( url, options ).then( cacheResponse )
                     return Promise.resolve( [{
                         request: null,
                         response: response,
@@ -705,6 +797,7 @@ const _fetch = ( url, options = {} ) => {
 
 }
 
+
 function deleteFromCache( _cache, url, response ) {
 
     _cache.delete( url );
@@ -712,10 +805,183 @@ function deleteFromCache( _cache, url, response ) {
 
 }
 
+function cacheFindAllLike( options ) {
+
+    const finalOptions = {
+        ...options,
+        findAll: true
+    }
+
+    return cacheFindLike( finalOptions );
+}
+
+function cacheFindLike( options ) {
+
+    const cache = options.cache;
+    const url = options.url;
+    const property = options.property;
+    const value = options.value;
+    const findAll = options.findAll;
+    const matchOptions = options.matchOptions
+    const method = options.method || "GET";
+
+    return cache.keys().then( ( keys ) => {
+
+        const matchingRequests = [];
+
+        for ( let i = 0; i < keys.length; i++ ) {
+
+            const request = keys[i];
+
+            if ( looksLikeResultListUrl( request.url, url ) ) {
+
+                matchingRequests.push( cache.match( request, matchOptions ).then( ( match ) => {
+
+                    match._request = request;
+
+                    return match;
+                } ) )
+
+            }
+
+        }
+
+        return Promise.all( matchingRequests ).then( ( responses ) => {
+            let count = 0;
+
+            const ret = [];
+
+            const checkCache = async ( index ) => {
+
+                if ( index >= responses.length ) return ret;
+
+                return serializeResponse( responses[index] ).then( json => {
+
+                    const items = extractDataArray( json );
+                    const response = responses[count];
+
+                    const retObj = {
+                        request: response._request,
+                        response: response,
+                        data: json,
+                        match: json,
+                        matchIndex: -1,
+                        status: {
+                            code: response.status,
+                            text: response.statusText,
+                            isAbort: false
+                        }
+                    }
+
+                    if ( method === "POST" ) {
+                        return findAll ? [retObj] : retObj;
+                    }
+
+                    const matchIndex = items.findIndex( item => item[property] === value );
+
+                    count++;
+
+                    if ( matchIndex >= 0 ) {
+
+                        retObj.match = items[matchIndex];
+                        retObj.matchIndex = matchIndex;
+
+                        if ( !findAll ) {
+                            return retObj;
+                        }
+                        else {
+                            ret.push( retObj );
+                        }
+
+                        return checkCache( count );
+                    }
+
+
+                    if ( count >= responses.length ) {
+                        return findAll ? ret : null;
+                    }
+
+                    return checkCache( count );
+
+                } )
+            }
+
+            if ( !responses || !responses.length ) return findAll ? ret : null;
+
+            return checkCache( count );
+        } )
+    } );
+
+
+}
+
+/**
+ * Check if request.url looks like a list result type url, if it contains a UUID it is likely not.
+ * @param {*} requestURL 
+ * @param {*} matchURL 
+ * @returns 
+ */
+function looksLikeResultListUrl( requestURL, matchURL ) {
+
+    const uuid = getUUID( requestURL.toString() );
+
+    return !uuid.id && requestURL.indexOf( matchURL ) >= 0;
+}
+
+
+function extractDataArray( obj ) {
+    for ( var prop in obj._embedded ) {
+        if ( !obj._embedded.hasOwnProperty( prop ) ) continue;
+        return obj._embedded[prop];
+    }
+
+    return [obj];
+}
+
+async function serializeResponse( response ) {
+
+    return response.text().then( data => {
+        return JSON.parse( data );
+    } )
+
+}
+
+function getUUID( str ) {
+
+    const UUID_REG_EXP = /.+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}).*?/;
+    const match = UUID_REG_EXP.exec( str );
+
+    let id, shortPath;
+
+    if ( match && match[1] ) {
+        id = match[1];
+        shortPath = str.split( `/${id}` )[0];
+    }
+
+    return {
+        id: id,
+        shortPath: shortPath
+    }
+
+}
+
+
+
+function getCacheNameFromUrl( url ) {
+
+    const API_REG_EXP = /p\/.+com\/(.*?)\//;
+    const matchArray = url.toString().match( API_REG_EXP );
+
+    return matchArray && matchArray.length >= 1 ? matchArray[1] : null;
+
+}
+
 function expiredCache( timeCached ) {
+
     const now = new Date().getTime();
 
     return Math.abs( now - timeCached ) >= CACHED_EXPIRY_TIMESTAMP;
+
 }
 
 export default _fetch;

package/lib/index.js

@@ -1,3 +1,5 @@
 export { default as Download } from './Download';
 export { default as fetch, applyMiddleware, OnOKResponse } from './Fetch';
+
+export * from "./utils/FetchUtils";
 export * from "./constants/FetchConstants";

package/lib/utils/FetchUtils.js

@@ -0,0 +1,118 @@
+import Fetch from '../Fetch';
+
+
+
+export const createUrlParams = ( params, existingParams ) => {
+
+
+    //SORT the params alphabetically, very important for cache lookups as the search a params in different order will cause it to not be matched.
+    params = Object.keys( params ).sort().reduce(
+        ( obj, key ) => {
+            obj[key] = params[key];
+            return obj;
+        },
+        {}
+    );
+
+    const searchParams = existingParams ? existingParams : new URLSearchParams();
+
+    for ( var prop in params ) {
+        if ( !params.hasOwnProperty( prop ) || params[prop] === undefined || params[prop] === null ) continue;
+
+        if ( Array.isArray( params[prop] ) ) {
+
+            if ( prop === "sort" ) {
+                searchParams.delete( "sort" );
+            }
+
+            for ( let i = 0; i < params[prop].length; i++ ) {
+                const e = params[prop][i];
+                if ( searchParams.has( prop ) && prop !== "sort" ) {
+                    searchParams.set( prop, e );
+                }
+                else {
+                    searchParams.append( prop, e );
+                }
+            }
+            continue;
+        }
+
+        if ( searchParams.has( prop ) ) {
+            searchParams.set( prop, params[prop] );
+        }
+        else {
+            searchParams.append( prop, params[prop] );
+        }
+    }
+
+
+    return searchParams;
+
+
+}
+
+
+export async function fetchPagedURL( url, callback, options ) {
+
+    const finalOptions = {
+        skipCache: false,
+        ...options
+    }
+
+    callback = callback ? callback : () => { };
+
+    let ret = [];
+
+    const proxyUrl = url.toString().split( "/p/" );
+
+    const [response] = await Fetch( url, finalOptions );
+    const { data, status } = response;
+
+    const size = new TextEncoder().encode( JSON.stringify( data ) ).length;
+    const kiloBytes = size / 1024;
+    const megaBytes = kiloBytes / 1024;
+
+    if ( status.code > 299 || status.code < 200 ) {
+        return [response, null];
+    }
+
+    const results = {
+        page: data.page.number + 1,
+        totalPages: data.page.totalPages,
+        totalElements: data.page.totalElements,
+        pageSize: data.page.size,
+        kiloBytes: kiloBytes,
+        megaBytes: megaBytes
+    }
+
+    data.items = data._embedded[[Object.keys( data._embedded )[0]]];
+
+    await callback( results, data.items );
+
+    ret = ret.concat( data.items || [] );
+
+    if ( data._links && data._links.next ) {
+
+        const nextUrl = new URL( `${proxyUrl[0]}/p/${data._links.next.href}` );
+
+        nextUrl.search = createUrlParams( {}, nextUrl.searchParams );
+
+        const [err, nextPage] = await fetchPagedURL( nextUrl, callback, options );
+
+        if ( err ) return [err, nextPage];
+
+        ret = ret.concat( nextPage );
+
+    }
+
+    return [null, ret];
+
+}
+
+
+function timeout( ms ) {
+
+    return new Promise( resolve => setTimeout( resolve, ms ) );
+
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selkirk-systems/fetch",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Abortable fetch library",
   "keywords": [],
   "author": "Marcos Bernal <mbernal@selkirksystems.com>",
@@ -36,5 +36,5 @@
   "peerDependencies": {
     "@selkirk-systems/state-management": ">=1.0.0"
   },
-  "gitHead": "319e3d6212d678f409052a628b9a28455ecc7ecd"
+  "gitHead": "29c0902c5e98d9679a6e4dd6977459265875ae2e"
 }