@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,243 @@
1
+ import type { OptimisticRollbackArgs, RequestInstance } from "@hyper-fetch/core";
2
+ import { Client } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+ import { act, renderHook, waitFor } from "@testing-library/react";
5
+ import { useFetch } from "hooks/use-fetch";
6
+ import { useSubmit } from "hooks/use-submit";
7
+ import { StrictMode } from "react";
8
+
9
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
10
+
11
+ type Data = { ok: boolean; mapped?: boolean };
12
+
13
+ /**
14
+ * Async response mapper which resolves only once the test releases it
15
+ */
16
+ const createGatedMapper = () => {
17
+ let release: () => void = () => undefined;
18
+ const gate = new Promise<void>((resolve) => {
19
+ release = resolve;
20
+ });
21
+ const calls = vi.fn();
22
+
23
+ // Mapping keeps the response type, so the request and its mocks stay typed with `Data`
24
+ const mapper = async <Response extends { data: Data | null }>(response: Response): Promise<Response> => {
25
+ calls();
26
+ await gate;
27
+ const data: Data | null = response.data ? { ...response.data, mapped: true } : null;
28
+ return { ...response, data };
29
+ };
30
+
31
+ return { mapper, calls, release };
32
+ };
33
+
34
+ /**
35
+ * The hook delivers callbacks in a promise continuation of the mapper - after a macrotask all of them have run
36
+ */
37
+ const flushPromises = () =>
38
+ new Promise<void>((resolve) => {
39
+ setTimeout(resolve, 0);
40
+ });
41
+
42
+ const createSetup = () => {
43
+ const client = new Client({ url: "shared-base-url" });
44
+ const list = client.createRequest<{ response: string[] }>()({ endpoint: "/list" });
45
+ const rollback = vi.fn((_args: OptimisticRollbackArgs<RequestInstance>) => undefined);
46
+ const invalidate = vi.spyOn(client.cache, "invalidate");
47
+ const gated = createGatedMapper();
48
+
49
+ const fetchRequest = client
50
+ .createRequest<{ response: Data }>()({ endpoint: "/fetch" })
51
+ .setResponseMapper(gated.mapper);
52
+ const submitRequest = client
53
+ .createRequest<{ response: Data }>()({ endpoint: "/submit", method: "POST" })
54
+ .setOptimistic(() => ({ rollback, invalidate: [list] }))
55
+ .setResponseMapper(gated.mapper);
56
+
57
+ return { client, list, rollback, invalidate, fetchRequest, submitRequest, ...gated };
58
+ };
59
+
60
+ const modes = [
61
+ { mode: "default", wrapper: undefined },
62
+ { mode: "StrictMode", wrapper: StrictMode },
63
+ ];
64
+
65
+ describe("useRequestEvents [ Async response mapper ]", () => {
66
+ beforeAll(() => {
67
+ startServer();
68
+ });
69
+
70
+ afterEach(() => {
71
+ resetMocks();
72
+ });
73
+
74
+ afterAll(() => {
75
+ stopServer();
76
+ });
77
+
78
+ describe.each(modes)("when rendered in $mode", ({ wrapper }) => {
79
+ const renderSubmit = (request: ReturnType<typeof createSetup>["submitRequest"]) => {
80
+ const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onFinished: vi.fn() };
81
+ const view = renderHook(() => useSubmit(request), { wrapper });
82
+
83
+ act(() => {
84
+ view.result.current.onSubmitSuccess(callbacks.onSuccess);
85
+ view.result.current.onSubmitError(callbacks.onError);
86
+ view.result.current.onSubmitFinished(callbacks.onFinished);
87
+ });
88
+
89
+ return { ...view, callbacks };
90
+ };
91
+
92
+ const renderFetch = (request: ReturnType<typeof createSetup>["fetchRequest"]) => {
93
+ const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onFinished: vi.fn() };
94
+ const view = renderHook(() => useFetch(request), { wrapper });
95
+
96
+ act(() => {
97
+ view.result.current.onSuccess(callbacks.onSuccess);
98
+ view.result.current.onError(callbacks.onError);
99
+ view.result.current.onFinished(callbacks.onFinished);
100
+ });
101
+
102
+ return { ...view, callbacks };
103
+ };
104
+
105
+ describe("when useSubmit unmounts while the mapper is pending", () => {
106
+ it("should fire no callback and invalidate once after success", async () => {
107
+ const setup = createSetup();
108
+ mockRequest(setup.submitRequest, { data: { ok: true } });
109
+ const { result, unmount, callbacks } = renderSubmit(setup.submitRequest);
110
+ let pending: ReturnType<typeof result.current.submit> | undefined;
111
+
112
+ act(() => {
113
+ pending = result.current.submit();
114
+ });
115
+ await waitFor(() => {
116
+ expect(setup.calls).toHaveBeenCalled();
117
+ });
118
+ unmount();
119
+ setup.release();
120
+ const response = await pending;
121
+ await flushPromises();
122
+
123
+ expect(response?.data).toStrictEqual({ ok: true, mapped: true });
124
+ expect(callbacks.onSuccess).not.toHaveBeenCalled();
125
+ expect(callbacks.onError).not.toHaveBeenCalled();
126
+ expect(callbacks.onFinished).not.toHaveBeenCalled();
127
+ expect(setup.invalidate).toHaveBeenCalledTimes(1);
128
+ expect(setup.invalidate).toHaveBeenCalledWith(setup.list);
129
+ expect(setup.rollback).not.toHaveBeenCalled();
130
+ });
131
+
132
+ it("should fire no callback and roll back once after error", async () => {
133
+ const setup = createSetup();
134
+ mockRequest(setup.submitRequest, { status: 400 });
135
+ const { result, unmount, callbacks } = renderSubmit(setup.submitRequest);
136
+ let pending: ReturnType<typeof result.current.submit> | undefined;
137
+
138
+ act(() => {
139
+ pending = result.current.submit();
140
+ });
141
+ await waitFor(() => {
142
+ expect(setup.calls).toHaveBeenCalled();
143
+ });
144
+ unmount();
145
+ setup.release();
146
+ const response = await pending;
147
+ await flushPromises();
148
+
149
+ expect(response?.status).toBe(400);
150
+ expect(callbacks.onSuccess).not.toHaveBeenCalled();
151
+ expect(callbacks.onError).not.toHaveBeenCalled();
152
+ expect(callbacks.onFinished).not.toHaveBeenCalled();
153
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
154
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("error");
155
+ expect(setup.invalidate).not.toHaveBeenCalled();
156
+ });
157
+ });
158
+
159
+ describe("when useSubmit stays mounted", () => {
160
+ it("should fire callbacks once with the mapped response", async () => {
161
+ const setup = createSetup();
162
+ mockRequest(setup.submitRequest, { data: { ok: true } });
163
+ const { result, callbacks } = renderSubmit(setup.submitRequest);
164
+ let pending: ReturnType<typeof result.current.submit> | undefined;
165
+
166
+ act(() => {
167
+ pending = result.current.submit();
168
+ });
169
+ await waitFor(() => {
170
+ expect(setup.calls).toHaveBeenCalled();
171
+ });
172
+ setup.release();
173
+ await act(async () => {
174
+ await pending;
175
+ });
176
+
177
+ await waitFor(() => {
178
+ expect(callbacks.onSuccess).toHaveBeenCalledTimes(1);
179
+ });
180
+ expect(callbacks.onSuccess.mock.calls[0][0].response.data).toStrictEqual({ ok: true, mapped: true });
181
+ expect(callbacks.onFinished).toHaveBeenCalledTimes(1);
182
+ expect(callbacks.onError).not.toHaveBeenCalled();
183
+ expect(setup.invalidate).toHaveBeenCalledTimes(1);
184
+ });
185
+ });
186
+
187
+ describe("when useFetch unmounts while the mapper is pending", () => {
188
+ it("should fire no callback after success", async () => {
189
+ const setup = createSetup();
190
+ mockRequest(setup.fetchRequest, { data: { ok: true } });
191
+ const { unmount, callbacks } = renderFetch(setup.fetchRequest);
192
+
193
+ await waitFor(() => {
194
+ expect(setup.calls).toHaveBeenCalled();
195
+ });
196
+ unmount();
197
+ setup.release();
198
+ await flushPromises();
199
+
200
+ expect(callbacks.onSuccess).not.toHaveBeenCalled();
201
+ expect(callbacks.onError).not.toHaveBeenCalled();
202
+ expect(callbacks.onFinished).not.toHaveBeenCalled();
203
+ });
204
+
205
+ it("should fire no callback after error", async () => {
206
+ const setup = createSetup();
207
+ mockRequest(setup.fetchRequest, { status: 400 });
208
+ const { unmount, callbacks } = renderFetch(setup.fetchRequest);
209
+
210
+ await waitFor(() => {
211
+ expect(setup.calls).toHaveBeenCalled();
212
+ });
213
+ unmount();
214
+ setup.release();
215
+ await flushPromises();
216
+
217
+ expect(callbacks.onSuccess).not.toHaveBeenCalled();
218
+ expect(callbacks.onError).not.toHaveBeenCalled();
219
+ expect(callbacks.onFinished).not.toHaveBeenCalled();
220
+ });
221
+ });
222
+
223
+ describe("when useFetch stays mounted", () => {
224
+ it("should fire callbacks once with the mapped response", async () => {
225
+ const setup = createSetup();
226
+ mockRequest(setup.fetchRequest, { data: { ok: true } });
227
+ const { callbacks } = renderFetch(setup.fetchRequest);
228
+
229
+ await waitFor(() => {
230
+ expect(setup.calls).toHaveBeenCalled();
231
+ });
232
+ setup.release();
233
+
234
+ await waitFor(() => {
235
+ expect(callbacks.onSuccess).toHaveBeenCalledTimes(1);
236
+ });
237
+ expect(callbacks.onSuccess.mock.calls[0][0].response.data).toStrictEqual({ ok: true, mapped: true });
238
+ expect(callbacks.onFinished).toHaveBeenCalledTimes(1);
239
+ expect(callbacks.onError).not.toHaveBeenCalled();
240
+ });
241
+ });
242
+ });
243
+ });
@@ -541,7 +541,7 @@ describe("useTrackedState [ Actions ]", () => {
541
541
  expect(result.current[0].loading).toBe(false);
542
542
  expect(result.current[0].status).toBe(null);
543
543
  expect(result.current[0].success).toBe(false);
544
- expect(result.current[0].extra).toBe(null);
544
+ expect(result.current[0].extra).toStrictEqual(request.client.adapter.defaultExtra);
545
545
  expect(result.current[0].retries).toBe(0);
546
546
  expect(result.current[0].responseTimestamp).toBe(null);
547
547
  expect(result.current[0].requestTimestamp).toBe(null);
@@ -0,0 +1,294 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import type { UseTrackedStateProps } from "helpers";
3
+ import { getRequestIdentity, getShouldClearState, useRequestEvents, useTrackedState } from "helpers";
4
+ import { isEqual } from "utils";
5
+
6
+ import { client, createRequest } from "../../../utils";
7
+ import { setCacheResponse } from "../../../utils/gate.utils";
8
+
9
+ type Data = { value: number };
10
+
11
+ describe("useTrackedState [ Request Keys ]", () => {
12
+ const logger = client.loggerManager.initialize(client, "test");
13
+
14
+ const renderTracked = <T extends ReturnType<typeof createRequest<Data>>>(
15
+ initialRequest: T,
16
+ options?: Partial<UseTrackedStateProps<T>>,
17
+ ) => {
18
+ const renders: { key: string; data: unknown; loading: boolean }[] = [];
19
+ const view = renderHook(
20
+ ({ request }: { request: T }) => {
21
+ const tracked = useTrackedState<T>({
22
+ logger,
23
+ request,
24
+ dispatcher: client.fetchDispatcher,
25
+ initialResponse: null,
26
+ deepCompare: isEqual,
27
+ dependencyTracking: false,
28
+ ...options,
29
+ });
30
+ renders.push({ key: request.cacheKey, data: tracked[0].data, loading: tracked[0].loading });
31
+ return tracked;
32
+ },
33
+ { initialProps: { request: initialRequest } },
34
+ );
35
+ return { ...view, renders };
36
+ };
37
+
38
+ beforeEach(() => {
39
+ client.clear();
40
+ });
41
+
42
+ describe("given getRequestIdentity util", () => {
43
+ it("should be the same for requests differing only by query params", () => {
44
+ const request = createRequest({ endpoint: "/users" as any });
45
+
46
+ expect(getRequestIdentity(request.setQueryParams({ page: 1, sort_by: "a" }))).toBe(
47
+ getRequestIdentity(request.setQueryParams({ page: 2, sort_by: "b" })),
48
+ );
49
+ });
50
+ it("should differ for requests with different params", () => {
51
+ const request = createRequest({ endpoint: "/users/:id" as any });
52
+
53
+ expect(getRequestIdentity(request.setParams({ id: 1 } as any))).not.toBe(
54
+ getRequestIdentity(request.setParams({ id: 2 } as any)),
55
+ );
56
+ });
57
+ it("should differ for requests with different methods", () => {
58
+ expect(getRequestIdentity(createRequest({ method: "GET" }))).not.toBe(
59
+ getRequestIdentity(createRequest({ method: "POST" })),
60
+ );
61
+ });
62
+ it("should differ for requests with different scopes", () => {
63
+ const request = createRequest();
64
+
65
+ expect(getRequestIdentity(request.setScope("a"))).not.toBe(getRequestIdentity(request.setScope("b")));
66
+ expect(getRequestIdentity(request.setScope("a"))).not.toBe(getRequestIdentity(request));
67
+ });
68
+ });
69
+
70
+ describe("given getShouldClearState util", () => {
71
+ it("should never clear for the same key", () => {
72
+ expect(getShouldClearState("clean", "GET_/users_", "GET_/users_")).toBeFalse();
73
+ expect(getShouldClearState("auto", "GET_/users_", "GET_/users_")).toBeFalse();
74
+ expect(getShouldClearState("preserve", "GET_/users_", "GET_/users_")).toBeFalse();
75
+ });
76
+ it("should always clear in the clean mode", () => {
77
+ expect(getShouldClearState("clean", 'GET_/users_{"page":1}', 'GET_/users_{"page":2}')).toBeTrue();
78
+ });
79
+ it("should never clear in the preserve mode", () => {
80
+ expect(getShouldClearState("preserve", "GET_/users/1_", "GET_/users/2_")).toBeFalse();
81
+ });
82
+ it("should clear in the auto mode when the endpoint changes", () => {
83
+ expect(getShouldClearState("auto", "GET_/users/1_", "GET_/users/2_")).toBeTrue();
84
+ });
85
+ it("should not clear in the auto mode when only the query params change", () => {
86
+ expect(getShouldClearState("auto", 'GET_/users_{"page":1}', 'GET_/users_{"page":2}')).toBeFalse();
87
+ });
88
+ });
89
+
90
+ describe("when the request key changes", () => {
91
+ it("should switch the state during the render with the new key", () => {
92
+ const request = createRequest<Data, any, "/items/:id">({ endpoint: "/items/:id" });
93
+ setCacheResponse(request.setParams({ id: 1 }), { value: 1 });
94
+ const { rerender, renders } = renderTracked(request.setParams({ id: 1 }) as any);
95
+
96
+ rerender({ request: request.setParams({ id: 2 }) as any });
97
+
98
+ const rendersOfNewKey = renders.filter((render) => render.key === request.setParams({ id: 2 }).cacheKey);
99
+ expect(rendersOfNewKey.map((render) => render.data)).toStrictEqual(rendersOfNewKey.map(() => null));
100
+ });
101
+ it("should use the cache of the new key during the render with it", () => {
102
+ const request = createRequest<Data, any, "/items/:id">({ endpoint: "/items/:id" });
103
+ setCacheResponse(request.setParams({ id: 1 }), { value: 1 });
104
+ setCacheResponse(request.setParams({ id: 2 }), { value: 2 });
105
+ const { rerender, renders } = renderTracked(request.setParams({ id: 1 }) as any);
106
+
107
+ rerender({ request: request.setParams({ id: 2 }) as any });
108
+
109
+ const firstRenderOfNewKey = renders.find((render) => render.key === request.setParams({ id: 2 }).cacheKey);
110
+ expect(firstRenderOfNewKey?.data).toStrictEqual({ value: 2 });
111
+ });
112
+ it("should keep the state for the query params change in the auto mode", () => {
113
+ const request = createRequest<Data>();
114
+ setCacheResponse(request.setQueryParams({ page_number: 1 }), { value: 1 });
115
+ const { rerender, result } = renderTracked(request.setQueryParams({ page_number: 1 }) as any);
116
+
117
+ rerender({ request: request.setQueryParams({ page_number: 2 }) as any });
118
+
119
+ expect(result.current[0].data).toStrictEqual({ value: 1 });
120
+ });
121
+ it("should clear the state for the query params change in the clean mode", () => {
122
+ const request = createRequest<Data>();
123
+ setCacheResponse(request.setQueryParams({ page: 1 }), { value: 1 });
124
+ const { rerender, result } = renderTracked(request.setQueryParams({ page: 1 }) as any, {
125
+ keepPreviousData: "clean",
126
+ });
127
+
128
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
129
+
130
+ expect(result.current[0].data).toBeNull();
131
+ });
132
+ it("should keep the state for the params change in the preserve mode", () => {
133
+ const request = createRequest<Data, any, "/items/:id">({ endpoint: "/items/:id" });
134
+ setCacheResponse(request.setParams({ id: 1 }), { value: 1 });
135
+ const { rerender, result } = renderTracked(request.setParams({ id: 1 }) as any, {
136
+ keepPreviousData: "preserve",
137
+ });
138
+
139
+ rerender({ request: request.setParams({ id: 2 }) as any });
140
+
141
+ expect(result.current[0].data).toStrictEqual({ value: 1 });
142
+ });
143
+ it("should not replace the kept state with the initial response", () => {
144
+ const request = createRequest<Data>();
145
+ setCacheResponse(request.setQueryParams({ page: 1 }), { value: 1 });
146
+ const { rerender, result } = renderTracked(request.setQueryParams({ page: 1 }) as any, {
147
+ initialResponse: { data: { value: 0 } },
148
+ });
149
+
150
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
151
+
152
+ expect(result.current[0].data).toStrictEqual({ value: 1 });
153
+ });
154
+ it("should use the initial response for the cleared state", () => {
155
+ const request = createRequest<Data>();
156
+ setCacheResponse(request.setQueryParams({ page: 1 }), { value: 1 });
157
+ const { rerender, result } = renderTracked(request.setQueryParams({ page: 1 }) as any, {
158
+ initialResponse: { data: { value: 0 } },
159
+ keepPreviousData: "clean",
160
+ });
161
+
162
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
163
+
164
+ expect(result.current[0].data).toStrictEqual({ value: 0 });
165
+ });
166
+ });
167
+
168
+ describe("when actions are used", () => {
169
+ it("should keep the identity of the actions between renders", () => {
170
+ const request = createRequest<Data>();
171
+ const { rerender, result } = renderTracked(request as any);
172
+ const actions = result.current[1];
173
+
174
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
175
+
176
+ expect(result.current[1]).toBe(actions);
177
+ });
178
+ it("should pass the status 0 to the updater", () => {
179
+ const request = createRequest<Data>();
180
+ const { result } = renderTracked(request as any);
181
+ const updater = vi.fn((previous: number | null) => (previous === 0 ? 500 : 200));
182
+
183
+ act(() => {
184
+ result.current[1].setStatus(0 as any);
185
+ });
186
+ act(() => {
187
+ result.current[1].setStatus(updater as any);
188
+ });
189
+
190
+ expect(updater).toHaveBeenCalledExactlyOnceWith(0);
191
+ expect(result.current[0].status).toBe(500);
192
+ });
193
+ });
194
+
195
+ describe("when used with useRequestEvents", () => {
196
+ const renderEvents = (request: ReturnType<typeof createRequest<Data>>) => {
197
+ return renderHook(() => {
198
+ const [state, actions, { setCacheData, getIsDataProcessing }] = useTrackedState({
199
+ logger,
200
+ request,
201
+ dispatcher: client.fetchDispatcher,
202
+ initialResponse: null,
203
+ deepCompare: isEqual,
204
+ dependencyTracking: false,
205
+ });
206
+ const [callbacks, listeners] = useRequestEvents({
207
+ logger,
208
+ actions,
209
+ request,
210
+ dispatcher: client.fetchDispatcher,
211
+ setCacheData,
212
+ getIsDataProcessing,
213
+ });
214
+ return { state, callbacks, listeners };
215
+ });
216
+ };
217
+
218
+ it("should keep the identity of the callbacks between renders", () => {
219
+ const { result, rerender } = renderEvents(createRequest<Data>());
220
+ const { callbacks } = result.current;
221
+
222
+ rerender();
223
+
224
+ expect(result.current.callbacks).toBe(callbacks);
225
+ });
226
+ it("should receive the cache data of the listened request", () => {
227
+ const request = createRequest<Data>();
228
+ const { result } = renderEvents(request);
229
+
230
+ act(() => {
231
+ result.current.listeners.addCacheDataListener(request);
232
+ setCacheResponse(request, { value: 1 });
233
+ });
234
+
235
+ expect(result.current.state.data).toStrictEqual({ value: 1 });
236
+ });
237
+ it("should ignore the cache data of another scope", () => {
238
+ const request = createRequest<Data>();
239
+ const { result } = renderEvents(request);
240
+
241
+ act(() => {
242
+ result.current.listeners.addCacheDataListener(request);
243
+ setCacheResponse(request.setScope("other"), { value: 1 });
244
+ });
245
+
246
+ expect(result.current.state.data).toBeNull();
247
+ });
248
+ it("should receive the cache data of the request listened with a scope", () => {
249
+ const request = createRequest<Data>().setScope("mine");
250
+ const { result } = renderEvents(request);
251
+
252
+ act(() => {
253
+ result.current.listeners.addCacheDataListener(request);
254
+ setCacheResponse(request, { value: 1 });
255
+ });
256
+
257
+ expect(result.current.state.data).toStrictEqual({ value: 1 });
258
+ });
259
+ it("should follow the loading events of the scoped request", () => {
260
+ const request = createRequest<Data>().setScope("mine");
261
+ const { result } = renderEvents(request);
262
+
263
+ act(() => {
264
+ result.current.listeners.addCacheDataListener(request);
265
+ client.requestManager.events.emitLoading({
266
+ request,
267
+ requestId: "1",
268
+ loading: true,
269
+ isRetry: false,
270
+ isOffline: false,
271
+ });
272
+ });
273
+
274
+ expect(result.current.state.loading).toBeTrue();
275
+ });
276
+ it("should ignore the loading events of another scope", () => {
277
+ const request = createRequest<Data>();
278
+ const { result } = renderEvents(request.setScope("mine"));
279
+
280
+ act(() => {
281
+ result.current.listeners.addCacheDataListener(request.setScope("mine"));
282
+ client.requestManager.events.emitLoading({
283
+ request: request.setScope("other"),
284
+ requestId: "1",
285
+ loading: true,
286
+ isRetry: false,
287
+ isOffline: false,
288
+ });
289
+ });
290
+
291
+ expect(result.current.state.loading).toBeFalse();
292
+ });
293
+ });
294
+ });
@@ -0,0 +1,127 @@
1
+ import { createTrackedProxy, getBounceData, isEmpty, isEqual } from "utils";
2
+
3
+ describe("Utils", () => {
4
+ describe("given createTrackedProxy util", () => {
5
+ const createProxy = () => {
6
+ const tracked = vi.fn();
7
+ const proxy = createTrackedProxy(
8
+ { data: 1, loading: false, refetch: () => "called" },
9
+ ["data", "loading"],
10
+ tracked,
11
+ );
12
+ return { proxy, tracked };
13
+ };
14
+
15
+ it("should return the values of the target", () => {
16
+ const { proxy } = createProxy();
17
+
18
+ expect(proxy.data).toBe(1);
19
+ expect(proxy.loading).toBeFalse();
20
+ expect(proxy.refetch()).toBe("called");
21
+ });
22
+ it("should report only the tracked keys that were read", () => {
23
+ const { proxy, tracked } = createProxy();
24
+
25
+ expect(proxy.data).toBe(1);
26
+ expect(proxy.refetch).toBeFunction();
27
+
28
+ expect(tracked.mock.calls).toStrictEqual([["data"]]);
29
+ });
30
+ it("should report nothing when nothing is read", () => {
31
+ const { tracked } = createProxy();
32
+
33
+ expect(tracked).not.toHaveBeenCalled();
34
+ });
35
+ it("should report every tracked key on destructuring with the rest", () => {
36
+ const { proxy, tracked } = createProxy();
37
+
38
+ const { ...rest } = proxy;
39
+
40
+ expect(rest.data).toBe(1);
41
+ expect(tracked.mock.calls.flat().toSorted()).toStrictEqual(["data", "loading"]);
42
+ });
43
+ it("should keep the keys enumerable", () => {
44
+ const { proxy } = createProxy();
45
+
46
+ expect(Object.keys(proxy)).toStrictEqual(["data", "loading", "refetch"]);
47
+ });
48
+ it("should not report symbol reads", () => {
49
+ const { proxy, tracked } = createProxy();
50
+
51
+ expect((proxy as Record<symbol, unknown>)[Symbol.toStringTag]).toBeUndefined();
52
+ expect(tracked).not.toHaveBeenCalled();
53
+ });
54
+ });
55
+
56
+ describe("given getBounceData util", () => {
57
+ it("should expose only the state and reset", () => {
58
+ const reset = vi.fn();
59
+ const bounce = getBounceData({ active: true, reset, debounce: vi.fn(), throttle: vi.fn() } as any);
60
+
61
+ expect(bounce.active).toBeTrue();
62
+ expect(bounce.reset).toBe(reset);
63
+ expect((bounce as Record<string, unknown>).debounce).toBeUndefined();
64
+ expect((bounce as Record<string, unknown>).throttle).toBeUndefined();
65
+ });
66
+ });
67
+
68
+ describe("given isEqual util", () => {
69
+ it.each([
70
+ [1, 1],
71
+ ["a", "a"],
72
+ [null, null],
73
+ [undefined, undefined],
74
+ [Number.NaN, Number.NaN],
75
+ [[], []],
76
+ [{}, {}],
77
+ [
78
+ [1, [2, { a: 3 }]],
79
+ [1, [2, { a: 3 }]],
80
+ ],
81
+ [{ a: { b: { c: [1, 2] } } }, { a: { b: { c: [1, 2] } } }],
82
+ [new Date(1000), new Date(1000)],
83
+ [{ a: undefined }, { a: undefined }],
84
+ ])("should treat %j and %j as equal", (first, second) => {
85
+ expect(isEqual(first, second)).toBeTrue();
86
+ });
87
+ it.each([
88
+ [1, 2],
89
+ [1, "1"],
90
+ [null, undefined],
91
+ [null, {}],
92
+ [[], {}],
93
+ [
94
+ [1, 2],
95
+ [2, 1],
96
+ ],
97
+ [[1], [1, 2]],
98
+ [{ a: 1 }, { a: 2 }],
99
+ [{ a: 1 }, { b: 1 }],
100
+ [{ a: 1 }, { a: 1, b: 2 }],
101
+ [{ a: { b: 1 } }, { a: { b: 2 } }],
102
+ [new Date(1000), new Date(2000)],
103
+ [0, false],
104
+ ["", null],
105
+ ])("should treat %j and %j as different", (first, second) => {
106
+ expect(isEqual(first, second)).toBeFalse();
107
+ });
108
+ it("should compare functions by reference", () => {
109
+ const callback = () => null;
110
+
111
+ expect(isEqual(callback, callback)).toBeTrue();
112
+ expect(isEqual(callback, () => null)).toBeFalse();
113
+ });
114
+ });
115
+
116
+ describe("given isEmpty util", () => {
117
+ it.each([[[]], [{}]])("should treat %j as empty", (value) => {
118
+ expect(isEmpty(value)).toBeTrue();
119
+ });
120
+ it.each([[[1]], [{ a: 1 }], [null], [undefined], [0], [""], [new Date()]])(
121
+ "should not treat %j as empty",
122
+ (value) => {
123
+ expect(isEmpty(value)).toBeFalse();
124
+ },
125
+ );
126
+ });
127
+ });