@hyper-fetch/react 9.6.0 → 9.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (102) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  3. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  4. package/__tests__/features/helpers/utils.spec.ts +127 -0
  5. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  6. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  7. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  8. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  9. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  10. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  11. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  12. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  13. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  14. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  15. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  16. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  17. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  18. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  19. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  20. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  21. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  22. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  23. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  24. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  25. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  26. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  27. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  28. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  29. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  30. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  31. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  32. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  33. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  34. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  35. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  36. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  37. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  38. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  39. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  40. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  41. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  42. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  43. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  44. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  45. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  46. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  47. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  48. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  49. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  50. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  51. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  52. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  53. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  54. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +8 -1
  55. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  56. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  57. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  58. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  59. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  60. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +2 -1
  61. package/__tests__/utils/gate.utils.ts +103 -0
  62. package/__tests__/utils/gated-client.utils.ts +158 -0
  63. package/__tests__/utils/helpers.utils.ts +19 -0
  64. package/__tests__/utils/use-queue.utils.ts +8 -4
  65. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  66. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  67. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  68. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  69. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  70. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  71. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  73. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  74. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  75. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  76. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  77. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  78. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  79. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  80. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  81. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  82. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  83. package/dist/index.mjs +633 -347
  84. package/dist/index.mjs.map +1 -1
  85. package/dist/provider/provider.d.ts.map +1 -1
  86. package/package.json +1 -1
  87. package/src/helpers/use-request-events/use-request-events.hooks.ts +147 -32
  88. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  89. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  90. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  91. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  92. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  93. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  94. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  95. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  96. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  97. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  98. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  99. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  100. package/src/provider/provider.tsx +9 -1
  101. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  102. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,167 @@
1
+ import { act, renderHook, waitFor } from "@testing-library/react";
2
+ import { useSubmit } from "hooks/use-submit";
3
+
4
+ import { createGatedClient } from "../../utils/gated-client.utils";
5
+
6
+ type User = { id: number; name: string };
7
+
8
+ const setup = (options?: { queued?: boolean }) => {
9
+ const gated = createGatedClient();
10
+ const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
11
+ endpoint: "/users",
12
+ method: "POST",
13
+ queued: options?.queued ?? false,
14
+ deduplicate: false,
15
+ });
16
+ /** Everything that got to the adapter, with the requests canceled by the library marked */
17
+ const sent = () =>
18
+ gated.calls.map((call) => ({ name: (call.request.payload as { name: string }).name, aborted: call.aborted }));
19
+ return { ...gated, request, sent };
20
+ };
21
+
22
+ /**
23
+ * The callbacks of a response run while the answered request is still in its queue. Submitting the next step
24
+ * from one of them must send only that step.
25
+ */
26
+ describe("useSubmit [ Chaining ]", () => {
27
+ describe.each([
28
+ ["concurrent", false],
29
+ ["queued", true],
30
+ ])("when the next %s submit is sent from a callback", (_name, queued) => {
31
+ it("should send only the next request from onSubmitSuccess", async () => {
32
+ const { request, waitForCall, sent } = setup({ queued });
33
+ const { result } = renderHook(() => {
34
+ const view = useSubmit(request, { dependencyTracking: false });
35
+ view.onSubmitSuccess(({ response }) => {
36
+ if (response.data.name === "First") {
37
+ view.submit({ payload: { name: "Second" } });
38
+ }
39
+ });
40
+ return view;
41
+ });
42
+ act(() => {
43
+ result.current.submit({ payload: { name: "First" } });
44
+ });
45
+ const firstCall = await waitForCall(0);
46
+
47
+ act(() => {
48
+ firstCall.succeed({ id: 1, name: "First" });
49
+ });
50
+ const secondCall = await waitForCall(1);
51
+ act(() => {
52
+ secondCall.succeed({ id: 2, name: "Second" });
53
+ });
54
+ await waitFor(() => {
55
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
56
+ });
57
+
58
+ expect(sent()).toStrictEqual([
59
+ { name: "First", aborted: false },
60
+ { name: "Second", aborted: false },
61
+ ]);
62
+ });
63
+
64
+ it("should send only the next request from onSubmitError", async () => {
65
+ const { request, waitForCall, sent } = setup({ queued });
66
+ let retried = false;
67
+ const { result } = renderHook(() => {
68
+ const view = useSubmit(request, { dependencyTracking: false });
69
+ view.onSubmitError(() => {
70
+ if (!retried) {
71
+ retried = true;
72
+ view.submit({ payload: { name: "Second" } });
73
+ }
74
+ });
75
+ return view;
76
+ });
77
+ act(() => {
78
+ result.current.submit({ payload: { name: "First" } });
79
+ });
80
+ const firstCall = await waitForCall(0);
81
+
82
+ act(() => {
83
+ firstCall.fail({ message: "Nope" }, 400);
84
+ });
85
+ const secondCall = await waitForCall(1);
86
+ act(() => {
87
+ secondCall.succeed({ id: 2, name: "Second" });
88
+ });
89
+ await waitFor(() => {
90
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
91
+ });
92
+
93
+ expect(sent()).toStrictEqual([
94
+ { name: "First", aborted: false },
95
+ { name: "Second", aborted: false },
96
+ ]);
97
+ });
98
+
99
+ it("should send only the next request from onSubmitFinished", async () => {
100
+ const { request, waitForCall, sent } = setup({ queued });
101
+ const { result } = renderHook(() => {
102
+ const view = useSubmit(request, { dependencyTracking: false });
103
+ view.onSubmitFinished(({ response }) => {
104
+ if (response.data?.name === "First") {
105
+ view.submit({ payload: { name: "Second" } });
106
+ }
107
+ });
108
+ return view;
109
+ });
110
+ act(() => {
111
+ result.current.submit({ payload: { name: "First" } });
112
+ });
113
+ const firstCall = await waitForCall(0);
114
+
115
+ act(() => {
116
+ firstCall.succeed({ id: 1, name: "First" });
117
+ });
118
+ const secondCall = await waitForCall(1);
119
+ act(() => {
120
+ secondCall.succeed({ id: 2, name: "Second" });
121
+ });
122
+ await waitFor(() => {
123
+ expect(result.current.submitting).toBeFalse();
124
+ });
125
+
126
+ expect(sent()).toStrictEqual([
127
+ { name: "First", aborted: false },
128
+ { name: "Second", aborted: false },
129
+ ]);
130
+ });
131
+
132
+ it("should call the success callback once for every step", async () => {
133
+ const { request, waitForCall } = setup({ queued });
134
+ const names: string[] = [];
135
+ const { result } = renderHook(() => {
136
+ const view = useSubmit(request, { dependencyTracking: false });
137
+ view.onSubmitSuccess(({ response }) => {
138
+ names.push(response.data.name);
139
+ if (response.data.name === "First") {
140
+ view.submit({ payload: { name: "Second" } });
141
+ }
142
+ });
143
+ return view;
144
+ });
145
+ act(() => {
146
+ result.current.submit({ payload: { name: "First" } });
147
+ });
148
+ const firstCall = await waitForCall(0);
149
+
150
+ act(() => {
151
+ firstCall.succeed({ id: 1, name: "First" });
152
+ });
153
+ const secondCall = await waitForCall(1);
154
+ act(() => {
155
+ secondCall.succeed({ id: 2, name: "Second" });
156
+ });
157
+ await waitFor(() => {
158
+ expect(names).toHaveLength(2);
159
+ });
160
+ await waitFor(() => {
161
+ expect(result.current.submitting).toBeFalse();
162
+ });
163
+
164
+ expect(names).toStrictEqual(["First", "Second"]);
165
+ });
166
+ });
167
+ });
@@ -45,7 +45,8 @@ describe("useSubmit [ Concurrency ]", () => {
45
45
  await testSuccessState(mock, responseTwo);
46
46
  });
47
47
  it("should start in loading mode when another request is ongoing", async () => {
48
- mockRequest(request);
48
+ // The default 20ms mock can resolve during the render pause below, so keep the request in flight explicitly
49
+ mockRequest(request, { delay: 1000 });
49
50
  const responseOne = renderUseSubmit(request);
50
51
 
51
52
  act(() => {
@@ -12,11 +12,42 @@ describe("useSubmit [ Bounce ]", () => {
12
12
 
13
13
  let request = createRequest<null, null>({ method: "POST" });
14
14
 
15
+ /**
16
+ * Bouncing is decided by elapsed time, so the timing specs run on a fake clock. With real timers a stall between two
17
+ * submits moves them into separate bounce windows and the request count changes.
18
+ */
19
+ const useFakeClock = () => {
20
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
21
+ };
22
+ const advance = (ms: number) => act(() => vi.advanceTimersByTimeAsync(ms));
23
+
24
+ /**
25
+ * Submits four times, 10ms apart, all inside one bounce window
26
+ */
27
+ const submitFourTimes = async (submit: () => unknown) => {
28
+ act(() => {
29
+ submit();
30
+ });
31
+ await advance(10);
32
+ act(() => {
33
+ submit();
34
+ });
35
+ await advance(10);
36
+ act(() => {
37
+ submit();
38
+ });
39
+ await advance(10);
40
+ act(() => {
41
+ submit();
42
+ });
43
+ };
44
+
15
45
  beforeAll(() => {
16
46
  startServer();
17
47
  });
18
48
 
19
49
  afterEach(() => {
50
+ vi.useRealTimers();
20
51
  resetMocks();
21
52
  });
22
53
 
@@ -33,52 +64,41 @@ describe("useSubmit [ Bounce ]", () => {
33
64
  describe("given debounce is active", () => {
34
65
  describe("when request is about to change", () => {
35
66
  it("should debounce single request", async () => {
36
- let submitTime: number | null = null;
37
- let startTime: number | null = null;
67
+ useFakeClock();
68
+ const spy = vi.fn();
38
69
  mockRequest(request);
39
70
  const response = renderUseSubmit(request, hookDebounceOptions);
40
71
 
41
72
  act(() => {
42
- response.result.current.onSubmitRequestStart(() => {
43
- startTime = Date.now();
44
- });
45
- submitTime = Date.now();
73
+ response.result.current.onSubmitRequestStart(spy);
46
74
  response.result.current.submit();
47
75
  });
48
76
 
49
- await waitFor(() => {
50
- expect(startTime).not.toBeNull();
51
- });
77
+ await advance(hookDebounceOptions.bounceTime - 1);
78
+ expect(spy).not.toHaveBeenCalled();
52
79
 
53
- expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookDebounceOptions.bounceTime);
80
+ await advance(1);
81
+ expect(spy).toHaveBeenCalledTimes(1);
54
82
  });
55
83
  it("should debounce multiple request triggers by bounceTime", async () => {
84
+ useFakeClock();
56
85
  const spy = vi.fn();
57
- let submitTime: number | null = null;
58
- let startTime: number | null = null;
59
86
  mockRequest(request);
60
87
  const response = renderUseSubmit(request, hookDebounceOptions);
61
88
 
62
- await act(async () => {
63
- response.result.current.onSubmitRequestStart(() => {
64
- spy();
65
- startTime = Date.now();
66
- });
67
- submitTime = Date.now();
68
- response.result.current.submit();
69
- await waitForRender(10);
70
- response.result.current.submit();
71
- await waitForRender(10);
72
- response.result.current.submit();
73
- await waitForRender(10);
74
- response.result.current.submit();
89
+ act(() => {
90
+ response.result.current.onSubmitRequestStart(spy);
75
91
  });
92
+ await submitFourTimes(response.result.current.submit);
76
93
 
77
- await waitFor(() => {
78
- expect(startTime).not.toBeNull();
79
- });
94
+ // The window restarts with every submit, so it closes bounceTime after the last one
95
+ await advance(hookDebounceOptions.bounceTime - 1);
96
+ expect(spy).not.toHaveBeenCalled();
80
97
 
81
- expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookDebounceOptions.bounceTime);
98
+ await advance(1);
99
+ expect(spy).toHaveBeenCalledTimes(1);
100
+
101
+ await advance(1000);
82
102
  expect(spy).toHaveBeenCalledTimes(1);
83
103
  });
84
104
  it("should resolve debounced methods", async () => {
@@ -106,39 +126,24 @@ describe("useSubmit [ Bounce ]", () => {
106
126
  expect(value).toHaveLength(4);
107
127
  });
108
128
  it("should change debounce time", async () => {
129
+ useFakeClock();
109
130
  const newBounceTime = 200;
110
131
  const spy = vi.fn();
111
- let submitTime: number | null = null;
112
- let startTime: number | null = null;
113
132
  mockRequest(request);
114
133
  const response = renderUseSubmit(request, hookDebounceOptions);
115
134
 
116
- await act(async () => {
117
- await response.rerender({ bounceTime: newBounceTime });
135
+ act(() => {
136
+ response.rerender({ bounceTime: newBounceTime });
118
137
  });
119
-
120
- await waitForRender(1);
121
-
122
- await act(async () => {
123
- response.result.current.onSubmitRequestStart(() => {
124
- spy();
125
- startTime = Date.now();
126
- });
127
- submitTime = Date.now();
128
- response.result.current.submit();
129
- await waitForRender(10);
130
- response.result.current.submit();
131
- await waitForRender(10);
132
- response.result.current.submit();
133
- await waitForRender(10);
134
- response.result.current.submit();
138
+ act(() => {
139
+ response.result.current.onSubmitRequestStart(spy);
135
140
  });
141
+ await submitFourTimes(response.result.current.submit);
136
142
 
137
- await waitFor(() => {
138
- expect(startTime).not.toBeNull();
139
- });
143
+ await advance(newBounceTime - 1);
144
+ expect(spy).not.toHaveBeenCalled();
140
145
 
141
- expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(newBounceTime);
146
+ await advance(1);
142
147
  expect(spy).toHaveBeenCalledTimes(1);
143
148
  });
144
149
  });
@@ -148,15 +153,11 @@ describe("useSubmit [ Bounce ]", () => {
148
153
  describe("when request is about to change", () => {
149
154
  it("should not debounce multiple request triggers", async () => {
150
155
  const spy = vi.fn();
151
- let startTime: number | null = null;
152
156
  mockRequest(request, { delay: 0 });
153
157
  const response = renderUseSubmit(request);
154
158
 
155
159
  await act(async () => {
156
- response.result.current.onSubmitRequestStart(() => {
157
- spy();
158
- startTime = Date.now();
159
- });
160
+ response.result.current.onSubmitRequestStart(spy);
160
161
  response.result.current.submit();
161
162
  await waitForRender(10);
162
163
  response.result.current.submit();
@@ -167,10 +168,8 @@ describe("useSubmit [ Bounce ]", () => {
167
168
  });
168
169
 
169
170
  await waitFor(() => {
170
- expect(startTime).not.toBeNull();
171
+ expect(spy).toHaveBeenCalledTimes(4);
171
172
  });
172
-
173
- expect(spy).toHaveBeenCalledTimes(4);
174
173
  });
175
174
  });
176
175
  });
@@ -178,52 +177,48 @@ describe("useSubmit [ Bounce ]", () => {
178
177
  describe("given throttle is active", () => {
179
178
  describe("when request is about to change", () => {
180
179
  it("should throttle single request", async () => {
181
- let submitTime: number | null = null;
182
- let startTime: number | null = null;
180
+ useFakeClock();
181
+ const spy = vi.fn();
183
182
  mockRequest(request);
184
183
  const response = renderUseSubmit(request, hookThrottleOptions);
185
184
 
186
185
  act(() => {
187
- response.result.current.onSubmitRequestStart(() => {
188
- startTime = Date.now();
189
- });
190
- submitTime = Date.now();
186
+ response.result.current.onSubmitRequestStart(spy);
191
187
  response.result.current.submit();
192
188
  response.result.current.submit();
193
189
  });
194
190
 
195
- await waitFor(() => {
196
- expect(startTime).not.toBeNull();
197
- expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookThrottleOptions.bounceTime);
198
- });
191
+ // Nothing was throttled yet, so the first submit is sent right away and the second waits for the timeout
192
+ await advance(0);
193
+ expect(spy).toHaveBeenCalledTimes(1);
194
+
195
+ await advance(hookThrottleOptions.bounceTimeout - 1);
196
+ expect(spy).toHaveBeenCalledTimes(1);
197
+
198
+ await advance(1);
199
+ expect(spy).toHaveBeenCalledTimes(2);
199
200
  });
200
201
  it("should throttle multiple request triggers by bounceTime", async () => {
202
+ useFakeClock();
201
203
  const spy = vi.fn();
202
- let submitTime: number | null = null;
203
- let startTime: number | null = null;
204
204
  mockRequest(request);
205
205
  const response = renderUseSubmit(request, hookThrottleOptions);
206
206
 
207
- await act(async () => {
208
- response.result.current.onSubmitRequestStart(() => {
209
- spy();
210
- startTime = Date.now();
211
- });
212
- submitTime = Date.now();
213
- response.result.current.submit();
214
- await waitForRender(10);
215
- response.result.current.submit();
216
- await waitForRender(10);
217
- response.result.current.submit();
218
- await waitForRender(10);
219
- response.result.current.submit();
207
+ act(() => {
208
+ response.result.current.onSubmitRequestStart(spy);
220
209
  });
210
+ await submitFourTimes(response.result.current.submit);
211
+ expect(spy).toHaveBeenCalledTimes(1);
221
212
 
222
- await waitFor(() => {
223
- expect(startTime).not.toBeNull();
224
- expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookThrottleOptions.bounceTime);
225
- expect(spy).toHaveBeenCalledTimes(2);
226
- });
213
+ // Only the last throttled submit is sent, bounceTimeout after it
214
+ await advance(hookThrottleOptions.bounceTimeout - 1);
215
+ expect(spy).toHaveBeenCalledTimes(1);
216
+
217
+ await advance(1);
218
+ expect(spy).toHaveBeenCalledTimes(2);
219
+
220
+ await advance(1000);
221
+ expect(spy).toHaveBeenCalledTimes(2);
227
222
  });
228
223
  it("should resolve throttled methods", async () => {
229
224
  mockRequest(request);
@@ -250,39 +245,26 @@ describe("useSubmit [ Bounce ]", () => {
250
245
  expect(value).toHaveLength(4);
251
246
  });
252
247
  it("should change throttle time", async () => {
248
+ useFakeClock();
253
249
  const newBounceTime = 200;
254
250
  const spy = vi.fn();
255
- let submitTime: number | null = null;
256
- let startTime: number | null = null;
257
251
  mockRequest(request);
258
252
  const response = renderUseSubmit(request, hookThrottleOptions);
259
253
 
260
- await act(async () => {
261
- await response.rerender({ bounceTime: newBounceTime, bounceTimeout: newBounceTime });
254
+ act(() => {
255
+ response.rerender({ bounceTime: newBounceTime, bounceTimeout: newBounceTime });
262
256
  });
263
-
264
- await waitForRender(1);
265
-
266
- await act(async () => {
267
- response.result.current.onSubmitRequestStart(() => {
268
- spy();
269
- startTime = Date.now();
270
- });
271
- submitTime = Date.now();
272
- response.result.current.submit();
273
- await waitForRender(10);
274
- response.result.current.submit();
275
- await waitForRender(10);
276
- response.result.current.submit();
277
- await waitForRender(10);
278
- response.result.current.submit();
257
+ act(() => {
258
+ response.result.current.onSubmitRequestStart(spy);
279
259
  });
260
+ await submitFourTimes(response.result.current.submit);
261
+ expect(spy).toHaveBeenCalledTimes(1);
280
262
 
281
- await waitFor(() => {
282
- expect(startTime).not.toBeNull();
283
- expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(newBounceTime);
284
- expect(spy).toHaveBeenCalledTimes(2);
285
- });
263
+ await advance(newBounceTime - 1);
264
+ expect(spy).toHaveBeenCalledTimes(1);
265
+
266
+ await advance(1);
267
+ expect(spy).toHaveBeenCalledTimes(2);
286
268
  });
287
269
  });
288
270
  });
@@ -291,15 +273,11 @@ describe("useSubmit [ Bounce ]", () => {
291
273
  describe("when request is about to change", () => {
292
274
  it("should not throttle multiple request triggers", async () => {
293
275
  const spy = vi.fn();
294
- let startTime: number | null = null;
295
276
  mockRequest(request, { delay: 0 });
296
277
  const response = renderUseSubmit(request);
297
278
 
298
279
  await act(async () => {
299
- response.result.current.onSubmitRequestStart(() => {
300
- spy();
301
- startTime = Date.now();
302
- });
280
+ response.result.current.onSubmitRequestStart(spy);
303
281
  response.result.current.submit();
304
282
  await waitForRender(10);
305
283
  response.result.current.submit();
@@ -310,10 +288,8 @@ describe("useSubmit [ Bounce ]", () => {
310
288
  });
311
289
 
312
290
  await waitFor(() => {
313
- expect(startTime).not.toBeNull();
291
+ expect(spy).toHaveBeenCalledTimes(4);
314
292
  });
315
-
316
- expect(spy).toHaveBeenCalledTimes(4);
317
293
  });
318
294
  });
319
295
  });