Respect function argument count

src/index.js

@@ -3,6 +3,13 @@ type EqualityFn = (a: mixed, b: mixed) => boolean;
 
 const simpleIsEqual: EqualityFn = (a: mixed, b: mixed): boolean => a === b;
 
+const defineProperty = (target: Object, property: string, value: mixed) =>
+  Object.defineProperty(target, property, {
+    writable: false,
+    configurable: true,
+    value: value,
+  });
+
 // <ResultFn: (...Array<any>) => mixed>
 // The purpose of this typing is to ensure that the returned memoized
 // function has the same type as the provided function (`resultFn`).
@@ -33,6 +40,10 @@ export default function <ResultFn: (...Array<any>) => mixed>(resultFn: ResultFn,
     return lastResult;
   };
 
+  defineProperty(result, 'length', resultFn.length);
+
+  defineProperty(result, 'name', `memoized_${resultFn.name || 'one'}`);
+
   // telling flow to ignore the type of `result` as we know it is `ResultFn`
   return (result: any);
 }

test/index.js

@@ -483,6 +483,24 @@ describe('memoizeOne', () => {
     });
   });
 
+  describe('js typing', () => {
+    it('should maintain function arguments count', () => {
+      expect(memoizeOne(a => a).length).to.equal(1);
+      expect(memoizeOne((a, b) => a + b).length).to.equal(2);
+      expect(memoizeOne((...rest) => rest).length).to.equal(0);
+      expect(memoizeOne((a, ...rest) => a + rest).length).to.equal(1);
+    });
+
+    it('should maintain function name', () => {
+      const fn = a => a;
+      expect(memoizeOne(fn).name).to.equal('memoized_fn');
+      expect(memoizeOne(a => a).name).to.equal('memoized_one');
+      expect(memoizeOne(function test(a) {
+        return a;
+      }).name).to.equal('memoized_test');
+    });
+  });
+
   describe('flow typing', () => {
     it('should maintain the type of the original function', () => {
       // this test will create a flow error if the typing is incorrect