resolves #11

resolves #10
resolves #8

Author: quisido

.gitignore

@@ -1,3 +1,3 @@
 /node_modules
-/fetch-suspense.js
 /fetch-suspense.d.ts
+/fetch-suspense.js

.mocharc.js

@@ -0,0 +1,21 @@
+module.exports = {
+  allowUncaught: false,
+  checkLeaks: true,
+  color: true,
+  diff: true,
+  extension: [ 'ts' ],
+  forbidOnly: true,
+  forbidPending: true,
+  fullTrace: false,
+  inlineDiff: true,
+  recursive: true,
+  require: [
+    '@babel/register',
+    'chai/register-expect',
+    'jsdom-global/register',
+    'ts-node/register',
+  ],
+  sort: true,
+  watch: false,
+  watchExtensions: [ 'ts' ],
+};

.npmignore

@@ -1,6 +1,9 @@
 /node_modules
+/src
+/tests
 /.gitignore
+/.mocharc.js
 /.npmignore
 /.travis.yml
 /tsconfig.json
-/fetch-suspense.ts
+/yarn.lock

fetch-suspense.ts

@@ -1,6 +1,6 @@
 {
   "name": "fetch-suspense",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "author": "Charles Stover <[email protected]>",
   "bugs": {
     "url": "https://github.com/CharlesStover/fetch-suspense/issues"
@@ -14,14 +14,25 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build",
-    "test": "exit 0"
+    "test": "mocha tests/**/*.test.ts"
   },
   "dependencies": {
     "deep-equal": "^1.0.1"
   },
   "devDependencies": {
+    "@babel/core": "^7.4.3",
+    "@babel/register": "^7.4.0",
+    "@types/chai": "^4.1.7",
     "@types/deep-equal": "^1.0.1",
+    "@types/mocha": "^5.2.6",
     "@types/node": "^10.12.1",
+    "@types/sinon": "^7.0.11",
+    "chai": "^4.2.0",
+    "jsdom": "^14.0.0",
+    "jsdom-global": "^3.0.2",
+    "mocha": "^6.1.3",
+    "sinon": "^7.3.1",
+    "ts-node": "^8.0.3",
     "typescript": "^3.1.5"
   }
 }

package.json

@@ -0,0 +1,124 @@
+import deepEqual = require('deep-equal');
+
+
+
+type CreateUseFetch = (fetch: GlobalFetch['fetch']) => UseFetch;
+
+interface Export extends UseFetch {
+  createUseFetch: CreateUseFetch;
+  default: UseFetch;
+}
+
+interface FetchCache {
+  fetch?: Promise<void>;
+  error?: any;
+  init: RequestInit | undefined;
+  input: RequestInfo;
+  response?: any;
+}
+
+type UseFetch = (
+  input: RequestInfo,
+  init?: RequestInit | undefined,
+  lifespan?: number,
+) => Object | string;
+
+
+
+const createUseFetch: CreateUseFetch = (
+  fetch: GlobalFetch['fetch'],
+): UseFetch => {
+
+  // Create a set of caches for this hook.
+  const caches: FetchCache[] = [];
+
+  return (
+    input: RequestInfo,
+    init?: RequestInit | undefined,
+    lifespan: number = 0,
+  ): Object | string => {
+
+    // Check each cache by this useFetch hook.
+    for (const cache of caches) {
+
+      // If this cache matches the request,
+      if (
+        deepEqual(input, cache.input) &&
+        deepEqual(init, cache.init)
+      ) {
+
+        // If an error occurred, throw it so that componentDidCatch can handle
+        //   it.
+        if (Object.prototype.hasOwnProperty.call(cache, 'error')) {
+          throw cache.error;
+        }
+  
+        // If a response was successful, return it.
+        if (Object.prototype.hasOwnProperty.call(cache, 'response')) {
+          return cache.response;
+        }
+
+        // If we are still waiting, throw the Promise so that Suspense can
+        //   fallback.
+        throw cache.fetch;
+      }
+    }
+
+    // If no request in the cache matched this one, create a new cache entry.
+    const cache: FetchCache = {
+
+      // Make the fetch request.
+      fetch: fetch(input, init)
+
+        // Parse the response.
+        .then((response: Response): Promise<Object | string> => {
+          const contentType: null | string =
+            response.headers.get('Content-Type');
+          if (
+            contentType &&
+            contentType.indexOf('application/json') !== -1
+          ) {
+            return response.json();
+          }
+          return response.text();
+        })
+
+        // Cache the response.
+        .then((response: Object | string): void => {
+          cache.response = response;
+        })
+
+        // Handle an error.
+        .catch((e: Error): void => {
+          cache.error = e;
+        })
+
+        // Invalidate the cache.
+        .then((): void => {
+          if (lifespan > 0) {
+            setTimeout(
+              (): void => {
+                const index: number = caches.indexOf(cache);
+                if (index !== -1) {
+                  caches.splice(index, 1);
+                }
+              },
+              lifespan,
+            );
+          }
+        }),
+      init,
+      input,
+    };
+    caches.push(cache);
+    throw cache.fetch;
+  };
+};
+
+const _export: Export = Object.assign(
+  createUseFetch(window.fetch), {
+  createUseFetch,
+  default: createUseFetch(window.fetch)
+});
+
+export = _export;

src/fetch-suspense.ts

@@ -0,0 +1,18 @@
+import { expect } from 'chai';
+import { createUseFetch } from '../fetch-suspense';
+import CommonJS = require('../fetch-suspense');
+
+
+
+describe('createUseFetch', (): void => {
+
+  it('should be a function with 1 parameter via CommonJS', (): void => {
+    expect(CommonJS.createUseFetch).to.be.a('function');
+    expect(CommonJS.createUseFetch.length).to.equal(1);
+  });
+
+  it('should be a function with 1 parameter via ES6', (): void => {
+    expect(createUseFetch).to.be.a('function');
+    expect(createUseFetch.length).to.equal(1);
+  });
+});

tests/create-use-fetch.test.ts

@@ -0,0 +1,18 @@
+import { expect } from 'chai';
+import useFetch from '../fetch-suspense';
+import CommonJS = require('../fetch-suspense');
+
+
+
+describe('useFetch', (): void => {
+
+  it('should be a function with 3 parameters via CommonJS', (): void => {
+    expect(CommonJS).to.be.a('function');
+    expect(CommonJS.length).to.equal(3);
+  });
+
+  it('should be a function with 3 parameters via ES6', (): void => {
+    expect(useFetch).to.be.a('function');
+    expect(useFetch.length).to.equal(3);
+  });
+});

tests/use-fetch.test.ts

@@ -0,0 +1,16 @@
+export const ERROR_REQUEST: RequestInfo = 'http://';
+
+export const JSON_REQUEST: RequestInfo = 'https://json';
+
+export const MOCK_ERROR: Error = new Error('Mock Error');
+
+export const MOCK_JSON: Object = {
+  mock: 'json',
+};
+
+export const MOCK_STRING: string = 'mock string';
+
+export const STRING_REQUEST: RequestInfo = 'https://string';
+
+export const UNKNOWN_ERROR: Error =
+  new Error('Test Error. The test should fail.');

tests/utils/constants.ts

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "declaration": true,
     "downlevelIteration": true,
-    "lib": [ "dom", "es5", "es2015.promise", "scripthost" ],
+    "lib": [ "dom", "es5", "es2015.promise", "es2017", "scripthost" ],
     "module": "commonjs",
     "moduleResolution": "Node",
     "noFallthroughCasesInSwitch": true,
@@ -18,5 +18,5 @@
     "strictPropertyInitialization": true,
     "target": "es5"
   },
-  "files": [ "fetch-suspense.ts" ]
+  "files": [ "src/fetch-suspense.ts" ]
 }