Merge pull request #1 from r24y/feat/no-proxy

New: Add `no-proxy` version for usage in Node 4

src/__tests__/no-proxy.test.js

@@ -0,0 +1,42 @@
+const anticipatedCall = require('../no-proxy');
+
+describe('no-proxy', () => {
+    describe('nextCall', () => {
+        test('should delay resolution until first call', () => {
+            const spy = jest.fn();
+            const myFn = anticipatedCall(spy);
+
+            const promise = myFn.anticipated.nextCall
+                .then(() => {
+                    expect(spy).toHaveBeenCalledTimes(1);
+                });
+            expect(spy).not.toHaveBeenCalled();
+            myFn();
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+        test('should return a new Promise', () => {
+            const myFn = anticipatedCall();
+            const promise1 = myFn.anticipated.nextCall;
+            const promise2 = myFn.anticipated.nextCall;
+            expect(promise1).not.toBe(promise2);
+        });
+        test('should handle subsequent calls as expected', () => {
+            const spy = jest.fn();
+            const myFn = anticipatedCall(spy);
+
+            const promise1 = myFn.anticipated.nextCall;
+
+            myFn();
+
+            return promise1.then(() => {
+                expect(spy).toHaveBeenCalledTimes(1);
+
+                const promise2 = myFn.anticipated.nextCall;
+                myFn();
+                return promise2;
+            }).then(() => {
+                expect(spy).toHaveBeenCalledTimes(2);
+            })
+        })
+    })
+})

src/index.js

@@ -38,4 +38,6 @@ function anticipateCall(fn = noop) {
   return new Proxy(fn, new Anticipated());
 }
 
-module.exports = anticipateCall;
+module.exports = anticipateCall;
+module.exports.Anticipated = Anticipated;
+module.exports.noop = noop;

src/no-proxy.js

@@ -0,0 +1,12 @@
+const {Anticipated, noop} = require('./index');
+
+function anticipateCallWithoutProxy(fn) {
+    const anticipated = new Anticipated();
+    function proxiedCall(...args) {
+        return anticipated.apply(fn, this, args);
+    }
+    proxiedCall.anticipated = anticipated;
+    return proxiedCall;
+}
+
+module.exports = anticipateCallWithoutProxy;