fix(compat/function/debounce): skip maxWait invocation when both leading and trailing are false

src/compat/function/debounce.spec.ts

@@ -359,8 +359,8 @@
     expect(actual).toEqual([false, true]);
   });
 
   // FIXME: flaky test
   it.skip('should queue a trailing call for subsequent debounced calls after `maxWait`', async () => {
     let callCount = 0;
 
     const debounced = debounce(
@@ -405,16 +405,16 @@
   });
 
   it('should invoke the trailing call with the correct arguments and `this` binding', async () => {
     let actual: any;
     let callCount = 0;
     const object = {};
 
     const debounced = debounce(
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       function (this: any, _: any) {
         actual = [this];
         // eslint-disable-next-line prefer-rest-params
         Array.prototype.push.apply(actual, arguments as any);
         return ++callCount !== 2;
       },
       32,
@@ -439,7 +439,7 @@
   const methodName = 'debounce';
 
   it(`\`_.${methodName}\` should not error for non-object \`options\` values`, () => {
     expect(() => func(noop, 32, 1 as any)).not.toThrow();
   });
 
   it(`\`_.${methodName}\` should use a default \`wait\` of \`0\``, async () => {
@@ -457,9 +457,9 @@
   });
 
   it(`\`_.${methodName}\` should invoke \`func\` with the correct \`this\` binding`, async () => {
     const actual: any[] = [];
     const object = {
       funced: func(function (this: any) {
         actual.push(this);
       }, 32),
     };
@@ -472,7 +472,7 @@
   });
 
   it(`\`_.${methodName}\` supports recursive calls`, async () => {
     const actual: any[] = [];
     const args = ['a', 'b', 'c'].map(chr => [{}, chr]);
     const expected = args.slice();
     const queue: any[] = args.slice();
@@ -559,6 +559,30 @@
     expect(callCount).toBe(0);
   });
 
+  it('should not invoke the function with `maxWait` when both `leading` and `trailing` are `false`', async () => {
+    let callCount = 0;
+
+    const debounced = debounce(
+      () => {
+        callCount++;
+      },
+      64,
+      { leading: false, trailing: false, maxWait: 64 }
+    );
+
+    debounced();
+    debounced();
+
+    await delay(96);
+
+    debounced();
+    debounced();
+
+    await delay(96);
+
+    expect(callCount).toBe(0);
+  });
+
   it('should match the type of lodash', () => {
     expectTypeOf(debounce).toEqualTypeOf<typeof debounceLodash>();
   });

src/compat/function/debounce.ts

@@ -198,7 +198,10 @@ export function debounce<F extends (...args: any[]) => any>(
       }
 
       if (Date.now() - pendingAt >= maxWait) {
-        result = func.apply(this, args);
+        if (leading || trailing) {
+          result = func.apply(this, args);
+        }
+
         pendingAt = Date.now();
 
         _debounced.cancel();

src/compat/function/throttle.spec.ts

@@ -353,6 +353,30 @@ describe('throttle', () => {
     expectTypeOf(throttle).toEqualTypeOf<typeof throttleLodash>();
   });
 
+  it('should not invoke the function when both `leading` and `trailing` are `false`', async () => {
+    let callCount = 0;
+
+    const throttled = throttle(
+      () => {
+        callCount++;
+      },
+      64,
+      { leading: false, trailing: false }
+    );
+
+    throttled();
+    throttled();
+
+    await delay(96);
+
+    throttled();
+    throttled();
+
+    await delay(96);
+
+    expect(callCount).toBe(0);
+  });
+
   it('should not invoke the function even after flush is called if timer is going', async () => {
     let callCount = 0;
     const throttled = throttle(() => ++callCount, 32);