@hyper-fetch/react 6.0.1 → 7.0.1

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 (45) hide show
  1. package/.eslintrc.json +8 -3
  2. package/README.md +5 -5
  3. package/dist/index.d.ts +167 -166
  4. package/dist/{index.esm.js → index.js} +462 -431
  5. package/dist/index.js.map +7 -0
  6. package/package.json +12 -13
  7. package/src/helpers/use-request-events/use-request-events.hooks.ts +79 -80
  8. package/src/helpers/use-request-events/use-request-events.types.ts +24 -22
  9. package/src/helpers/use-socket-state/use-socket-state.constants.ts +4 -1
  10. package/src/helpers/use-socket-state/use-socket-state.hooks.ts +39 -29
  11. package/src/helpers/use-socket-state/use-socket-state.types.ts +4 -1
  12. package/src/helpers/use-tracked-state/use-tracked-state.constants.ts +4 -3
  13. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +82 -115
  14. package/src/helpers/use-tracked-state/use-tracked-state.types.ts +42 -25
  15. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +45 -41
  16. package/src/hooks/use-app-manager/use-app-manager.hooks.ts +2 -2
  17. package/src/hooks/use-cache/use-cache.constants.ts +1 -1
  18. package/src/hooks/use-cache/use-cache.hooks.ts +32 -27
  19. package/src/hooks/use-cache/use-cache.types.ts +4 -22
  20. package/src/hooks/use-emitter/use-emitter.hooks.ts +50 -18
  21. package/src/hooks/use-fetch/use-fetch.constants.ts +6 -5
  22. package/src/hooks/use-fetch/use-fetch.hooks.ts +71 -79
  23. package/src/hooks/use-fetch/use-fetch.types.ts +28 -9
  24. package/src/hooks/use-listener/use-listener.hooks.ts +15 -21
  25. package/src/hooks/use-queue/use-queue.constants.ts +2 -1
  26. package/src/hooks/use-queue/use-queue.hooks.ts +123 -42
  27. package/src/hooks/use-queue/use-queue.types.ts +14 -5
  28. package/src/hooks/use-submit/use-submit.constants.ts +3 -3
  29. package/src/hooks/use-submit/use-submit.hooks.ts +39 -53
  30. package/src/hooks/use-submit/use-submit.types.ts +5 -6
  31. package/src/index.ts +1 -3
  32. package/src/provider/index.ts +2 -0
  33. package/src/{config-provider/config-provider.tsx → provider/provider.tsx} +8 -5
  34. package/src/{config-provider/config-provider.types.ts → provider/provider.types.ts} +15 -8
  35. package/src/utils/deep-equal.utils.ts +1 -3
  36. package/tsconfig.json +2 -2
  37. package/dist/index.cjs.js +0 -1550
  38. package/dist/index.cjs.js.map +0 -7
  39. package/dist/index.esm.js.map +0 -7
  40. package/src/config-provider/index.ts +0 -2
  41. package/src/hooks/use-event-messages/index.ts +0 -2
  42. package/src/hooks/use-event-messages/use-event-messages.hooks.ts +0 -69
  43. package/src/hooks/use-event-messages/use-event-messages.types.ts +0 -4
  44. package/src/types/index.ts +0 -1
  45. package/src/types/invalidation.types.ts +0 -3
package/dist/index.cjs.js DELETED
@@ -1,1550 +0,0 @@
1
- var __create = Object.create;
2
- var __defProp = Object.defineProperty;
3
- var __defProps = Object.defineProperties;
4
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
- var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
6
- var __getOwnPropNames = Object.getOwnPropertyNames;
7
- var __getOwnPropSymbols = Object.getOwnPropertySymbols;
8
- var __getProtoOf = Object.getPrototypeOf;
9
- var __hasOwnProp = Object.prototype.hasOwnProperty;
10
- var __propIsEnum = Object.prototype.propertyIsEnumerable;
11
- var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
12
- var __spreadValues = (a, b) => {
13
- for (var prop in b || (b = {}))
14
- if (__hasOwnProp.call(b, prop))
15
- __defNormalProp(a, prop, b[prop]);
16
- if (__getOwnPropSymbols)
17
- for (var prop of __getOwnPropSymbols(b)) {
18
- if (__propIsEnum.call(b, prop))
19
- __defNormalProp(a, prop, b[prop]);
20
- }
21
- return a;
22
- };
23
- var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
24
- var __export = (target, all) => {
25
- for (var name in all)
26
- __defProp(target, name, { get: all[name], enumerable: true });
27
- };
28
- var __copyProps = (to, from, except, desc) => {
29
- if (from && typeof from === "object" || typeof from === "function") {
30
- for (let key of __getOwnPropNames(from))
31
- if (!__hasOwnProp.call(to, key) && key !== except)
32
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
33
- }
34
- return to;
35
- };
36
- var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
37
- isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
38
- mod
39
- ));
40
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
41
- var __async = (__this, __arguments, generator) => {
42
- return new Promise((resolve, reject) => {
43
- var fulfilled = (value) => {
44
- try {
45
- step(generator.next(value));
46
- } catch (e) {
47
- reject(e);
48
- }
49
- };
50
- var rejected = (value) => {
51
- try {
52
- step(generator.throw(value));
53
- } catch (e) {
54
- reject(e);
55
- }
56
- };
57
- var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
58
- step((generator = generator.apply(__this, __arguments)).next());
59
- });
60
- };
61
-
62
- // src/index.ts
63
- var src_exports = {};
64
- __export(src_exports, {
65
- ConfigProvider: () => ConfigProvider,
66
- getBounceData: () => getBounceData,
67
- getDetailsState: () => getDetailsState,
68
- getInitialState: () => getInitialState,
69
- getIsInitiallyLoading: () => getIsInitiallyLoading,
70
- getRefreshTime: () => getRefreshTime,
71
- getTimestamp: () => getTimestamp,
72
- getValidCacheData: () => getValidCacheData,
73
- initialSocketState: () => initialSocketState,
74
- initialState: () => initialState,
75
- isEmpty: () => isEmpty,
76
- isEqual: () => isEqual,
77
- isStaleCacheData: () => isStaleCacheData,
78
- useAppManager: () => useAppManager,
79
- useCache: () => useCache,
80
- useCacheDefaultOptions: () => useCacheDefaultOptions,
81
- useConfigProvider: () => useConfigProvider,
82
- useEmitter: () => useEmitter,
83
- useEventMessages: () => useEventMessages,
84
- useFetch: () => useFetch,
85
- useFetchDefaultOptions: () => useFetchDefaultOptions,
86
- useListener: () => useListener,
87
- useQueue: () => useQueue,
88
- useQueueDefaultOptions: () => useQueueDefaultOptions,
89
- useRequestEvents: () => useRequestEvents,
90
- useSocketState: () => useSocketState,
91
- useSubmit: () => useSubmit,
92
- useSubmitDefaultOptions: () => useSubmitDefaultOptions,
93
- useTrackedState: () => useTrackedState
94
- });
95
- module.exports = __toCommonJS(src_exports);
96
-
97
- // src/hooks/use-fetch/use-fetch.hooks.ts
98
- var import_react5 = require("react");
99
- var import_lifecycle4 = require("@better-hooks/lifecycle");
100
- var import_performance = require("@better-hooks/performance");
101
- var import_core = require("@hyper-fetch/core");
102
-
103
- // src/helpers/use-request-events/use-request-events.hooks.ts
104
- var import_react = require("react");
105
- var import_lifecycle = require("@better-hooks/lifecycle");
106
- var useRequestEvents = ({
107
- request,
108
- dispatcher,
109
- logger,
110
- actions,
111
- setCacheData,
112
- getIsDataProcessing
113
- }) => {
114
- const { responseMapper } = request;
115
- const { cache, requestManager } = request.client;
116
- const onSuccessCallback = (0, import_react.useRef)(null);
117
- const onErrorCallback = (0, import_react.useRef)(null);
118
- const onAbortCallback = (0, import_react.useRef)(null);
119
- const onOfflineErrorCallback = (0, import_react.useRef)(null);
120
- const onFinishedCallback = (0, import_react.useRef)(null);
121
- const onRequestStartCallback = (0, import_react.useRef)(null);
122
- const onResponseStartCallback = (0, import_react.useRef)(null);
123
- const onDownloadProgressCallback = (0, import_react.useRef)(null);
124
- const onUploadProgressCallback = (0, import_react.useRef)(null);
125
- const lifecycleEvents = (0, import_react.useRef)(/* @__PURE__ */ new Map());
126
- const dataEvents = (0, import_react.useRef)(null);
127
- const removeLifecycleListener = (requestId) => {
128
- const event = lifecycleEvents.current.get(requestId);
129
- event == null ? void 0 : event.unmount();
130
- lifecycleEvents.current.delete(requestId);
131
- };
132
- const clearLifecycleListeners = () => {
133
- const events = lifecycleEvents.current;
134
- const listeners = Array.from(events.values());
135
- listeners.forEach((value) => {
136
- value.unmount();
137
- });
138
- events.clear();
139
- };
140
- const handleResponseCallbacks = (cmd, response, details) => {
141
- var _a, _b, _c, _d, _e;
142
- const { data, error, success } = response;
143
- const { isOffline, isCanceled } = details;
144
- if (request.offline && isOffline && !success) {
145
- logger.debug("Performing offline error callback", { data, details });
146
- (_a = onOfflineErrorCallback.current) == null ? void 0 : _a.call(onOfflineErrorCallback, { response: error, request: cmd, details });
147
- } else if (isCanceled) {
148
- logger.debug("Performing abort callback", { data, details });
149
- (_b = onAbortCallback.current) == null ? void 0 : _b.call(onAbortCallback, { response: error, request: cmd, details });
150
- } else if (success) {
151
- logger.debug("Performing success callback", { data, details });
152
- (_c = onSuccessCallback.current) == null ? void 0 : _c.call(onSuccessCallback, { response: data, request: cmd, details });
153
- } else {
154
- logger.debug("Performing error callback", { data, details });
155
- (_d = onErrorCallback.current) == null ? void 0 : _d.call(onErrorCallback, { response: error, request: cmd, details });
156
- }
157
- (_e = onFinishedCallback.current) == null ? void 0 : _e.call(onFinishedCallback, { response, request: cmd, details });
158
- };
159
- const handleGetLoadingEvent = (req) => {
160
- return ({ loading }) => {
161
- const isProcessing = getIsDataProcessing(req.cacheKey);
162
- if (isProcessing)
163
- return;
164
- const canDisableLoading = !loading && !dispatcher.hasRunningRequests(req.queueKey);
165
- if (loading || canDisableLoading) {
166
- actions.setLoading(loading, false);
167
- }
168
- };
169
- };
170
- const handleDownloadProgress = (progress, details) => {
171
- var _a;
172
- (_a = onDownloadProgressCallback.current) == null ? void 0 : _a.call(onDownloadProgressCallback, progress, details);
173
- };
174
- const handleUploadProgress = (progress, details) => {
175
- var _a;
176
- (_a = onUploadProgressCallback.current) == null ? void 0 : _a.call(onUploadProgressCallback, progress, details);
177
- };
178
- const handleRequestStart = (cmd) => {
179
- return (details) => {
180
- var _a;
181
- (_a = onRequestStartCallback.current) == null ? void 0 : _a.call(onRequestStartCallback, { request: cmd, details });
182
- };
183
- };
184
- const handleResponseStart = (cmd) => {
185
- return (details) => {
186
- var _a;
187
- (_a = onResponseStartCallback.current) == null ? void 0 : _a.call(onResponseStartCallback, { request: cmd, details });
188
- };
189
- };
190
- const handleResponse = (req) => {
191
- return (response, details) => {
192
- const data = responseMapper ? responseMapper(response) : response;
193
- if (data instanceof Promise) {
194
- return (() => __async(void 0, null, function* () {
195
- const promiseData = yield data;
196
- handleResponseCallbacks(req, promiseData, details);
197
- }))();
198
- }
199
- return handleResponseCallbacks(req, data, details);
200
- };
201
- };
202
- const handleRemove = ({ requestId }) => {
203
- removeLifecycleListener(requestId);
204
- };
205
- const clearCacheDataListener = () => {
206
- var _a;
207
- (_a = dataEvents.current) == null ? void 0 : _a.unmount();
208
- dataEvents.current = null;
209
- };
210
- const addCacheDataListener = (req) => {
211
- const loadingUnmount = requestManager.events.onLoading(req.queueKey, handleGetLoadingEvent(req));
212
- const getResponseUnmount = cache.events.onData(
213
- req.cacheKey,
214
- setCacheData
215
- );
216
- const unmount = () => {
217
- loadingUnmount();
218
- getResponseUnmount();
219
- };
220
- clearCacheDataListener();
221
- dataEvents.current = { unmount };
222
- return unmount;
223
- };
224
- const addLifecycleListeners = (req, requestId) => {
225
- if (!requestId) {
226
- clearLifecycleListeners();
227
- const { queueKey, cacheKey } = req;
228
- const requestStartUnmount2 = requestManager.events.onRequestStart(queueKey, handleRequestStart(req));
229
- const responseStartUnmount2 = requestManager.events.onResponseStart(queueKey, handleResponseStart(req));
230
- const uploadUnmount2 = requestManager.events.onUploadProgress(queueKey, handleUploadProgress);
231
- const downloadUnmount2 = requestManager.events.onDownloadProgress(queueKey, handleDownloadProgress);
232
- const responseUnmount2 = requestManager.events.onResponse(cacheKey, handleResponse(req));
233
- const unmount2 = () => {
234
- downloadUnmount2();
235
- uploadUnmount2();
236
- requestStartUnmount2();
237
- responseStartUnmount2();
238
- responseUnmount2();
239
- };
240
- lifecycleEvents.current.set(queueKey, { unmount: unmount2 });
241
- return unmount2;
242
- }
243
- const requestRemove = requestManager.events.onRemoveById(requestId, handleRemove);
244
- const requestStartUnmount = requestManager.events.onRequestStartById(requestId, handleRequestStart(req));
245
- const responseStartUnmount = requestManager.events.onResponseStartById(requestId, handleResponseStart(req));
246
- const responseUnmount = requestManager.events.onResponseById(requestId, handleResponse(req));
247
- const uploadUnmount = requestManager.events.onUploadProgressById(requestId, handleUploadProgress);
248
- const downloadUnmount = requestManager.events.onDownloadProgressById(requestId, handleDownloadProgress);
249
- const unmount = () => {
250
- requestRemove();
251
- downloadUnmount();
252
- uploadUnmount();
253
- requestStartUnmount();
254
- responseStartUnmount();
255
- responseUnmount();
256
- };
257
- lifecycleEvents.current.set(requestId, { unmount });
258
- return unmount;
259
- };
260
- const abort = () => {
261
- const { abortKey } = request;
262
- const requests = dispatcher.getAllRunningRequest();
263
- requests.forEach((requestData) => {
264
- if (requestData.request.abortKey === abortKey) {
265
- dispatcher.delete(requestData.request.queueKey, requestData.requestId, abortKey);
266
- }
267
- });
268
- };
269
- (0, import_lifecycle.useWillUnmount)(() => {
270
- clearLifecycleListeners();
271
- clearCacheDataListener();
272
- });
273
- return [
274
- {
275
- abort,
276
- onSuccess: (callback) => {
277
- onSuccessCallback.current = callback;
278
- },
279
- onError: (callback) => {
280
- onErrorCallback.current = callback;
281
- },
282
- onAbort: (callback) => {
283
- onAbortCallback.current = callback;
284
- },
285
- onOfflineError: (callback) => {
286
- onOfflineErrorCallback.current = callback;
287
- },
288
- onFinished: (callback) => {
289
- onFinishedCallback.current = callback;
290
- },
291
- onRequestStart: (callback) => {
292
- onRequestStartCallback.current = callback;
293
- },
294
- onResponseStart: (callback) => {
295
- onResponseStartCallback.current = callback;
296
- },
297
- onDownloadProgress: (callback) => {
298
- onDownloadProgressCallback.current = callback;
299
- },
300
- onUploadProgress: (callback) => {
301
- onUploadProgressCallback.current = callback;
302
- }
303
- },
304
- {
305
- addCacheDataListener,
306
- clearCacheDataListener,
307
- addLifecycleListeners,
308
- removeLifecycleListener,
309
- clearLifecycleListeners
310
- }
311
- ];
312
- };
313
-
314
- // src/helpers/use-tracked-state/use-tracked-state.constants.ts
315
- var initialState = {
316
- data: null,
317
- error: null,
318
- status: null,
319
- extra: null,
320
- success: null,
321
- loading: false,
322
- retries: 0,
323
- timestamp: null
324
- };
325
-
326
- // src/helpers/use-tracked-state/use-tracked-state.hooks.ts
327
- var import_react2 = require("react");
328
- var import_lifecycle2 = require("@better-hooks/lifecycle");
329
-
330
- // src/utils/deep-equal.utils.ts
331
- var isEmpty = (value) => {
332
- const valueType = Object.prototype.toString.call(value);
333
- if (Array.isArray(value))
334
- return !value.length;
335
- if (typeof value === "object" && value !== null && valueType === "[object Object]")
336
- return !Object.keys(value).length;
337
- return false;
338
- };
339
- var isEqual = (firstValue, secondValue) => {
340
- if (firstValue === secondValue)
341
- return true;
342
- try {
343
- const firstValueType = Object.prototype.toString.call(firstValue);
344
- const secondValueType = Object.prototype.toString.call(secondValue);
345
- const firstType = typeof firstValue;
346
- const secondType = typeof secondValue;
347
- const isType = (type) => firstType === type && secondType === type;
348
- const isTypeValue = (type) => firstValueType === type && secondValueType === type;
349
- if (firstValueType !== secondValueType)
350
- return false;
351
- if (firstValue === null && secondValue === null)
352
- return true;
353
- if (isType("number") && Number.isNaN(firstValue) && Number.isNaN(secondValue))
354
- return true;
355
- if (isEmpty(firstValue) && isEmpty(secondValue))
356
- return true;
357
- if (Array.isArray(firstValue) && Array.isArray(secondValue)) {
358
- if (firstValue.length !== secondValue.length)
359
- return false;
360
- return !firstValue.some((element, i) => !isEqual(element, secondValue[i]));
361
- }
362
- if (isType("object") && isTypeValue("[object Object]")) {
363
- if (Object.keys(firstValue).length !== Object.keys(secondValue).length)
364
- return false;
365
- return !Object.entries(firstValue).some(
366
- ([key, value]) => !isEqual(value, secondValue[key])
367
- );
368
- }
369
- if (firstValue instanceof Date && secondValue instanceof Date) {
370
- return +firstValue === +secondValue;
371
- }
372
- return firstValue === secondValue;
373
- } catch (err) {
374
- console.error(err);
375
- return false;
376
- }
377
- };
378
-
379
- // src/utils/bounce.utils.ts
380
- var getBounceData = (bounceData) => {
381
- return __spreadValues(__spreadValues({}, bounceData), { throttle: void 0, debounce: void 0 });
382
- };
383
-
384
- // src/helpers/use-tracked-state/use-tracked-state.utils.ts
385
- var getDetailsState = (state, details) => {
386
- return __spreadValues({
387
- retries: (state == null ? void 0 : state.retries) || 0,
388
- timestamp: +new Date(),
389
- isCanceled: false,
390
- isOffline: false
391
- }, details);
392
- };
393
- var isStaleCacheData = (cacheTime, cacheTimestamp) => {
394
- if (!cacheTimestamp)
395
- return true;
396
- return +new Date() > +cacheTimestamp + cacheTime;
397
- };
398
- var getValidCacheData = (request, initialData, cacheData) => {
399
- const isStale = isStaleCacheData(request.cacheTime, cacheData == null ? void 0 : cacheData.timestamp);
400
- if (!isStale && cacheData) {
401
- return cacheData;
402
- }
403
- if (initialData) {
404
- return __spreadProps(__spreadValues(__spreadValues({
405
- data: null,
406
- error: null,
407
- status: null,
408
- success: null,
409
- extra: null
410
- }, initialData || {}), getDetailsState()), {
411
- cacheTime: 1e3,
412
- clearKey: request.client.cache.clearKey,
413
- garbageCollection: request.garbageCollection
414
- });
415
- }
416
- return null;
417
- };
418
- var getTimestamp = (timestamp) => {
419
- return timestamp ? new Date(timestamp) : null;
420
- };
421
- var getIsInitiallyLoading = ({
422
- queryKey,
423
- dispatcher,
424
- hasState,
425
- revalidate,
426
- disabled
427
- }) => {
428
- if (!revalidate && hasState) {
429
- return false;
430
- }
431
- const queue = dispatcher.getQueue(queryKey);
432
- const isInitiallyLoading = dispatcher.hasRunningRequests(queryKey) || !queue.stopped && disabled === false;
433
- return isInitiallyLoading;
434
- };
435
- var getInitialState = ({
436
- initialResponse,
437
- dispatcher,
438
- request,
439
- disabled,
440
- revalidate
441
- }) => {
442
- const { client, cacheKey, responseMapper } = request;
443
- const { cache } = client;
444
- const cacheData = cache.get(cacheKey);
445
- const cacheState = getValidCacheData(request, initialResponse, cacheData);
446
- const initialLoading = getIsInitiallyLoading({
447
- queryKey: request.queueKey,
448
- dispatcher,
449
- disabled,
450
- revalidate,
451
- hasState: !!cacheState
452
- });
453
- if (cacheState) {
454
- const mappedData = responseMapper ? responseMapper(cacheState) : cacheState;
455
- if (mappedData instanceof Promise) {
456
- return initialState;
457
- }
458
- return {
459
- data: mappedData.data,
460
- error: mappedData.error,
461
- status: mappedData.status,
462
- success: mappedData.success,
463
- extra: mappedData.extra,
464
- retries: cacheState.retries,
465
- timestamp: getTimestamp(cacheState.timestamp),
466
- loading: initialLoading
467
- };
468
- }
469
- return {
470
- data: initialState.data,
471
- error: initialState.error,
472
- status: initialState.status,
473
- success: initialState.success,
474
- extra: request.client.defaultExtra,
475
- retries: initialState.retries,
476
- timestamp: getTimestamp(initialState.timestamp),
477
- loading: initialLoading
478
- };
479
- };
480
-
481
- // src/helpers/use-tracked-state/use-tracked-state.hooks.ts
482
- var useTrackedState = ({
483
- request,
484
- dispatcher,
485
- initialData,
486
- deepCompare,
487
- dependencyTracking,
488
- defaultCacheEmitting = true,
489
- disabled,
490
- revalidate
491
- }) => {
492
- const { client, cacheKey, queueKey, cacheTime, responseMapper } = request;
493
- const { cache, requestManager } = client;
494
- const forceUpdate = (0, import_lifecycle2.useForceUpdate)();
495
- const state = (0, import_react2.useRef)(
496
- getInitialState({ initialResponse: initialData, dispatcher, request, disabled })
497
- );
498
- const renderKeys = (0, import_react2.useRef)([]);
499
- const isProcessingData = (0, import_react2.useRef)("");
500
- const getStaleStatus = () => {
501
- const cacheData = cache.get(cacheKey);
502
- return !cacheData || isStaleCacheData(cacheTime, cacheData == null ? void 0 : cacheData.timestamp);
503
- };
504
- const renderKeyTrigger = (keys) => {
505
- const shouldRerender = renderKeys.current.some((renderKey) => keys.includes(renderKey));
506
- if (shouldRerender)
507
- forceUpdate();
508
- };
509
- const setRenderKey = (renderKey) => {
510
- if (!renderKeys.current.includes(renderKey)) {
511
- renderKeys.current.push(renderKey);
512
- }
513
- };
514
- (0, import_lifecycle2.useDidUpdate)(
515
- () => {
516
- state.current.loading = dispatcher.hasRunningRequests(queueKey);
517
- const cacheData = cache.get(cacheKey);
518
- const cacheState = getValidCacheData(request, initialData, cacheData);
519
- state.current.loading = getIsInitiallyLoading({
520
- queryKey: request.queueKey,
521
- dispatcher,
522
- disabled,
523
- revalidate,
524
- hasState: !!cacheState
525
- });
526
- const hasInitialState = isEqual(initialData == null ? void 0 : initialData.data, state.current.data);
527
- const hasState = !!(state.current.data || state.current.error) && !hasInitialState;
528
- const shouldLoadInitialCache = !hasState && !!state.current.data;
529
- const shouldRemovePreviousData = hasState && !state.current.data;
530
- if (cacheState || shouldLoadInitialCache || shouldRemovePreviousData) {
531
- setCacheData(cacheState);
532
- }
533
- },
534
- [cacheKey, queueKey],
535
- true
536
- );
537
- (0, import_lifecycle2.useDidUpdate)(
538
- () => {
539
- const handleDependencyTracking = () => {
540
- if (!dependencyTracking) {
541
- Object.keys(state.current).forEach((key) => setRenderKey(key));
542
- }
543
- };
544
- handleDependencyTracking();
545
- },
546
- [dependencyTracking],
547
- true
548
- );
549
- const handleCompare = (firstValue, secondValue) => {
550
- if (typeof deepCompare === "function") {
551
- return deepCompare(firstValue, secondValue);
552
- }
553
- if (deepCompare) {
554
- return isEqual(firstValue, secondValue);
555
- }
556
- return false;
557
- };
558
- const handleCacheData = (cacheData) => {
559
- const newStateValues = {
560
- data: cacheData.data,
561
- error: cacheData.error,
562
- status: cacheData.status,
563
- success: cacheData.success,
564
- extra: cacheData.extra,
565
- retries: cacheData.retries,
566
- timestamp: new Date(cacheData.timestamp),
567
- loading: dispatcher.hasRunningRequests(queueKey)
568
- };
569
- const changedKeys = Object.keys(newStateValues).filter((key) => {
570
- const keyValue = key;
571
- const firstValue = state.current[keyValue];
572
- const secondValue = newStateValues[keyValue];
573
- return !handleCompare(firstValue, secondValue);
574
- });
575
- state.current = __spreadValues(__spreadValues({}, state.current), newStateValues);
576
- renderKeyTrigger(changedKeys);
577
- };
578
- const setIsDataProcessing = ({
579
- processingCacheKey,
580
- isProcessing
581
- }) => {
582
- if (isProcessing) {
583
- isProcessingData.current = processingCacheKey;
584
- } else if (isProcessingData.current === cacheKey) {
585
- isProcessingData.current = "";
586
- }
587
- };
588
- const getIsDataProcessing = (processingCacheKey) => {
589
- return isProcessingData.current === processingCacheKey;
590
- };
591
- const setCacheData = (cacheData) => {
592
- setIsDataProcessing({ processingCacheKey: cacheKey, isProcessing: true });
593
- const data = responseMapper ? responseMapper(cacheData) : cacheData;
594
- if (data instanceof Promise) {
595
- return (() => __async(void 0, null, function* () {
596
- const promiseData = yield data;
597
- handleCacheData(__spreadValues(__spreadValues({}, cacheData), promiseData));
598
- setIsDataProcessing({ processingCacheKey: cacheKey, isProcessing: false });
599
- }))();
600
- }
601
- setIsDataProcessing({ processingCacheKey: cacheKey, isProcessing: false });
602
- return handleCacheData(__spreadValues(__spreadValues({}, cacheData), data));
603
- };
604
- const actions = {
605
- setData: (data, emitToCache = defaultCacheEmitting) => {
606
- if (emitToCache) {
607
- const currentState = state.current;
608
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success: true, data }));
609
- } else {
610
- state.current.data = data;
611
- renderKeyTrigger(["data"]);
612
- }
613
- },
614
- setError: (error, emitToCache = defaultCacheEmitting) => {
615
- if (emitToCache) {
616
- const currentState = state.current;
617
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success: false, error }));
618
- } else {
619
- state.current.error = error;
620
- renderKeyTrigger(["error"]);
621
- }
622
- },
623
- setLoading: (loading, emitToHooks = true) => {
624
- if (emitToHooks) {
625
- requestManager.events.emitLoading(queueKey, "", {
626
- queueKey,
627
- requestId: "",
628
- loading,
629
- isRetry: false,
630
- isOffline: false
631
- });
632
- } else if (loading !== state.current.loading) {
633
- state.current.loading = loading;
634
- renderKeyTrigger(["loading"]);
635
- }
636
- },
637
- setStatus: (status, emitToCache = defaultCacheEmitting) => {
638
- if (emitToCache) {
639
- const currentState = state.current;
640
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { status }));
641
- } else {
642
- state.current.status = status;
643
- renderKeyTrigger(["status"]);
644
- }
645
- },
646
- setSuccess: (success, emitToCache = defaultCacheEmitting) => {
647
- if (emitToCache) {
648
- const currentState = state.current;
649
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success }));
650
- } else {
651
- state.current.success = success;
652
- renderKeyTrigger(["success"]);
653
- }
654
- },
655
- setExtra: (extra, emitToCache = defaultCacheEmitting) => {
656
- if (emitToCache) {
657
- const currentState = state.current;
658
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { extra }));
659
- } else {
660
- state.current.extra = extra;
661
- renderKeyTrigger(["extra"]);
662
- }
663
- },
664
- setRetries: (retries, emitToCache = defaultCacheEmitting) => {
665
- if (emitToCache) {
666
- const currentState = state.current;
667
- cache.set(request, __spreadValues(__spreadValues({}, currentState), getDetailsState(state.current, { retries })));
668
- } else {
669
- state.current.retries = retries;
670
- renderKeyTrigger(["retries"]);
671
- }
672
- },
673
- setTimestamp: (timestamp, emitToCache = defaultCacheEmitting) => {
674
- if (emitToCache) {
675
- const currentState = state.current;
676
- cache.set(request, __spreadValues(__spreadValues({}, currentState), getDetailsState(state.current, { timestamp: +timestamp })));
677
- } else {
678
- state.current.timestamp = timestamp;
679
- renderKeyTrigger(["timestamp"]);
680
- }
681
- }
682
- };
683
- return [state.current, actions, { setRenderKey, setCacheData, getStaleStatus, getIsDataProcessing }];
684
- };
685
-
686
- // src/helpers/use-socket-state/use-socket-state.hooks.ts
687
- var import_react3 = require("react");
688
- var import_lifecycle3 = require("@better-hooks/lifecycle");
689
- var useSocketState = (socket, { dependencyTracking }) => {
690
- const forceUpdate = (0, import_lifecycle3.useForceUpdate)();
691
- const onOpenCallback = (0, import_react3.useRef)(null);
692
- const onCloseCallback = (0, import_react3.useRef)(null);
693
- const onErrorCallback = (0, import_react3.useRef)(null);
694
- const onConnectingCallback = (0, import_react3.useRef)(null);
695
- const onReconnectingCallback = (0, import_react3.useRef)(null);
696
- const onReconnectingStopCallback = (0, import_react3.useRef)(null);
697
- const state = (0, import_react3.useRef)(initialSocketState);
698
- const renderKeys = (0, import_react3.useRef)([]);
699
- const renderKeyTrigger = (keys) => {
700
- const shouldRerender = renderKeys.current.some((renderKey) => keys.includes(renderKey));
701
- if (shouldRerender)
702
- forceUpdate();
703
- };
704
- const setRenderKey = (renderKey) => {
705
- if (!renderKeys.current.includes(renderKey)) {
706
- renderKeys.current.push(renderKey);
707
- }
708
- };
709
- (0, import_lifecycle3.useDidUpdate)(
710
- () => {
711
- const handleDependencyTracking = () => {
712
- if (!dependencyTracking) {
713
- Object.keys(state.current).forEach((key) => setRenderKey(key));
714
- }
715
- };
716
- handleDependencyTracking();
717
- },
718
- [dependencyTracking],
719
- true
720
- );
721
- const actions = {
722
- setData: (data) => {
723
- state.current.data = data;
724
- renderKeyTrigger(["data"]);
725
- },
726
- setConnected: (connected) => {
727
- state.current.connected = connected;
728
- renderKeyTrigger(["data"]);
729
- },
730
- setConnecting: (connecting) => {
731
- state.current.connecting = connecting;
732
- renderKeyTrigger(["data"]);
733
- },
734
- setTimestamp: (timestamp) => {
735
- state.current.timestamp = timestamp;
736
- renderKeyTrigger(["timestamp"]);
737
- }
738
- };
739
- const callbacks = {
740
- onOpen: (callback) => {
741
- onOpenCallback.current = callback;
742
- },
743
- onClose: (callback) => {
744
- onCloseCallback.current = callback;
745
- },
746
- onError: (callback) => {
747
- onErrorCallback.current = callback;
748
- },
749
- onConnecting: (callback) => {
750
- onConnectingCallback.current = callback;
751
- },
752
- onReconnecting: (callback) => {
753
- onReconnectingCallback.current = callback;
754
- },
755
- onReconnectingStop: (callback) => {
756
- onReconnectingStopCallback.current = callback;
757
- }
758
- };
759
- (0, import_lifecycle3.useDidMount)(() => {
760
- const umountOnError = socket.events.onError((event) => {
761
- var _a;
762
- (_a = onErrorCallback.current) == null ? void 0 : _a.call(onErrorCallback, event);
763
- });
764
- const umountOnConnecting = socket.events.onConnecting(() => {
765
- var _a;
766
- actions.setConnecting(true);
767
- (_a = onConnectingCallback.current) == null ? void 0 : _a.call(onConnectingCallback);
768
- });
769
- const umountOnOpen = socket.events.onOpen(() => {
770
- var _a;
771
- actions.setConnected(true);
772
- (_a = onOpenCallback.current) == null ? void 0 : _a.call(onOpenCallback);
773
- });
774
- const umountOnClose = socket.events.onClose(() => {
775
- var _a;
776
- actions.setConnected(false);
777
- (_a = onCloseCallback.current) == null ? void 0 : _a.call(onCloseCallback);
778
- });
779
- const umountOnReconnecting = socket.events.onReconnecting((attempts) => {
780
- var _a;
781
- (_a = onReconnectingCallback.current) == null ? void 0 : _a.call(onReconnectingCallback, attempts);
782
- });
783
- const umountOnReconnectingStop = socket.events.onReconnectingStop((attempts) => {
784
- var _a;
785
- (_a = onReconnectingStopCallback.current) == null ? void 0 : _a.call(onReconnectingStopCallback, attempts);
786
- });
787
- return () => {
788
- umountOnError();
789
- umountOnConnecting();
790
- umountOnOpen();
791
- umountOnClose();
792
- umountOnReconnecting();
793
- umountOnReconnectingStop();
794
- };
795
- });
796
- return [state.current, actions, callbacks, { setRenderKey }];
797
- };
798
-
799
- // src/helpers/use-socket-state/use-socket-state.constants.ts
800
- var initialSocketState = {
801
- data: null,
802
- connected: false,
803
- connecting: false,
804
- timestamp: null
805
- };
806
-
807
- // src/config-provider/config-provider.tsx
808
- var import_react4 = __toESM(require("react"));
809
- var import_jsx_runtime = require("react/jsx-runtime");
810
- var ConfigContext = import_react4.default.createContext([{}, () => null]);
811
- var ConfigProvider = ({ children, config }) => {
812
- const [currentConfig, setConfig] = (0, import_react4.useState)(config || {});
813
- const value = (0, import_react4.useMemo)(() => {
814
- const contextValue = [currentConfig, setConfig];
815
- return contextValue;
816
- }, [currentConfig]);
817
- return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConfigContext.Provider, { value, children });
818
- };
819
- var useConfigProvider = () => {
820
- const config = (0, import_react4.useContext)(ConfigContext);
821
- return config;
822
- };
823
-
824
- // src/hooks/use-fetch/use-fetch.hooks.ts
825
- var useFetch = (request, options = useFetchDefaultOptions) => {
826
- const [globalConfig] = useConfigProvider();
827
- const {
828
- dependencies = useFetchDefaultOptions.dependencies,
829
- disabled = useFetchDefaultOptions.disabled,
830
- dependencyTracking = useFetchDefaultOptions.dependencyTracking,
831
- revalidate = useFetchDefaultOptions.revalidate,
832
- initialData = useFetchDefaultOptions.initialData,
833
- refresh = useFetchDefaultOptions.refresh,
834
- refreshTime = useFetchDefaultOptions.refreshTime,
835
- refetchBlurred = useFetchDefaultOptions.refetchBlurred,
836
- refetchOnBlur = useFetchDefaultOptions.refetchOnBlur,
837
- refetchOnFocus = useFetchDefaultOptions.refetchOnFocus,
838
- refetchOnReconnect = useFetchDefaultOptions.refetchOnReconnect,
839
- bounce = useFetchDefaultOptions.bounce,
840
- bounceType = useFetchDefaultOptions.bounceType,
841
- bounceTime = useFetchDefaultOptions.bounceTime,
842
- bounceTimeout = useFetchDefaultOptions.bounceTime,
843
- deepCompare = useFetchDefaultOptions.deepCompare
844
- } = __spreadValues(__spreadValues(__spreadValues({}, useFetchDefaultOptions), globalConfig.useFetchConfig), options);
845
- const updateKey = JSON.stringify(request.toJSON());
846
- const requestDebounce = (0, import_performance.useDebounce)({ delay: bounceTime });
847
- const requestThrottle = (0, import_performance.useThrottle)({ interval: bounceTime, timeout: bounceTimeout });
848
- const refreshDebounce = (0, import_performance.useDebounce)({ delay: refreshTime });
849
- const { cacheKey, queueKey, client } = request;
850
- const { cache, fetchDispatcher: dispatcher, appManager, loggerManager } = client;
851
- const ignoreReact18DoubleRender = (0, import_react5.useRef)(true);
852
- const logger = (0, import_react5.useRef)(loggerManager.init("useFetch")).current;
853
- const bounceData = bounceType === "throttle" ? requestThrottle : requestDebounce;
854
- const bounceFunction = bounceType === "throttle" ? requestThrottle.throttle : requestDebounce.debounce;
855
- const [state, actions, { setRenderKey, setCacheData, getStaleStatus, getIsDataProcessing }] = useTrackedState({
856
- logger,
857
- request,
858
- dispatcher,
859
- initialData,
860
- deepCompare,
861
- dependencyTracking,
862
- disabled,
863
- revalidate
864
- });
865
- const [callbacks, listeners] = useRequestEvents({
866
- logger,
867
- actions,
868
- request,
869
- dispatcher,
870
- setCacheData,
871
- getIsDataProcessing
872
- });
873
- const { addCacheDataListener, addLifecycleListeners, clearCacheDataListener } = listeners;
874
- const handleFetch = () => {
875
- if (!disabled) {
876
- logger.debug(`Fetching data`);
877
- dispatcher.add(request);
878
- } else {
879
- logger.debug(`Cannot add to fetch queue`, { disabled });
880
- }
881
- };
882
- function handleRefresh() {
883
- if (!refresh) {
884
- refreshDebounce.reset();
885
- return;
886
- }
887
- refreshDebounce.debounce(() => {
888
- const isBlurred = !appManager.isFocused;
889
- const isFetching = dispatcher.hasRunningRequests(request.queueKey);
890
- const isQueued = dispatcher.getIsActiveQueue(request.queueKey);
891
- const isActive = isFetching || isQueued;
892
- const canRefreshBlurred = isBlurred && refetchBlurred && !isActive;
893
- const canRefreshFocused = !isBlurred && !isActive;
894
- if (canRefreshBlurred || canRefreshFocused) {
895
- handleFetch();
896
- logger.debug(`Performing refresh request`);
897
- }
898
- handleRefresh();
899
- });
900
- }
901
- const handleInvalidation = (invalidateKey) => {
902
- if (invalidateKey && invalidateKey instanceof import_core.Request) {
903
- cache.invalidate((0, import_core.getRequestKey)(invalidateKey));
904
- } else if (invalidateKey && !(invalidateKey instanceof import_core.Request)) {
905
- cache.invalidate(invalidateKey);
906
- }
907
- };
908
- const refetch = (invalidateKey) => {
909
- if (invalidateKey && Array.isArray(invalidateKey)) {
910
- invalidateKey.forEach(handleInvalidation);
911
- } else if (invalidateKey && !Array.isArray(invalidateKey)) {
912
- handleInvalidation(invalidateKey);
913
- } else {
914
- handleFetch();
915
- handleRefresh();
916
- }
917
- };
918
- const getIsFetchingIdentity = () => {
919
- return dispatcher.getRunningRequests(queueKey).some((running) => running.request.cacheKey === cacheKey);
920
- };
921
- const initialFetchData = () => {
922
- const hasStaleData = getStaleStatus();
923
- const isFetching = getIsFetchingIdentity();
924
- if ((revalidate || hasStaleData) && !isFetching) {
925
- handleFetch();
926
- }
927
- };
928
- const updateFetchData = () => {
929
- const hasStaleData = getStaleStatus();
930
- const shouldUpdate = !revalidate ? hasStaleData : true;
931
- if (!ignoreReact18DoubleRender.current && shouldUpdate) {
932
- if (bounce) {
933
- logger.debug(`Bounce request with ${bounceType}`, { queueKey, request });
934
- bounceFunction(() => handleFetch());
935
- } else {
936
- handleFetch();
937
- }
938
- } else {
939
- ignoreReact18DoubleRender.current = false;
940
- }
941
- };
942
- const handleMountEvents = () => {
943
- addCacheDataListener(request);
944
- addLifecycleListeners(request);
945
- const focusUnmount = appManager.events.onFocus(() => {
946
- if (refetchOnFocus) {
947
- handleFetch();
948
- handleRefresh();
949
- }
950
- });
951
- const blurUnmount = appManager.events.onBlur(() => {
952
- if (refetchOnBlur) {
953
- handleFetch();
954
- handleRefresh();
955
- }
956
- });
957
- const onlineUnmount = appManager.events.onOnline(() => {
958
- if (refetchOnReconnect) {
959
- handleFetch();
960
- handleRefresh();
961
- }
962
- });
963
- const invalidateUnmount = cache.events.onInvalidate(cacheKey, handleFetch);
964
- const unmount = () => {
965
- clearCacheDataListener();
966
- focusUnmount();
967
- blurUnmount();
968
- onlineUnmount();
969
- invalidateUnmount();
970
- };
971
- return unmount;
972
- };
973
- (0, import_lifecycle4.useDidUpdate)(handleMountEvents, [updateKey], true);
974
- (0, import_lifecycle4.useDidMount)(initialFetchData);
975
- (0, import_lifecycle4.useDidUpdate)(updateFetchData, [updateKey, disabled, ...dependencies], true);
976
- (0, import_lifecycle4.useDidUpdate)(handleRefresh, [updateKey, ...dependencies, disabled, refresh, refreshTime], true);
977
- (0, import_lifecycle4.useWillUnmount)(() => {
978
- ignoreReact18DoubleRender.current = true;
979
- });
980
- return __spreadProps(__spreadValues(__spreadValues({
981
- get data() {
982
- setRenderKey("data");
983
- return state.data;
984
- },
985
- get error() {
986
- setRenderKey("error");
987
- return state.error;
988
- },
989
- get loading() {
990
- setRenderKey("loading");
991
- return state.loading;
992
- },
993
- get status() {
994
- setRenderKey("status");
995
- return state.status;
996
- },
997
- get success() {
998
- setRenderKey("success");
999
- return state.success;
1000
- },
1001
- get extra() {
1002
- setRenderKey("extra");
1003
- return state.extra;
1004
- },
1005
- get retries() {
1006
- setRenderKey("retries");
1007
- return state.retries;
1008
- },
1009
- get timestamp() {
1010
- setRenderKey("timestamp");
1011
- return state.timestamp;
1012
- },
1013
- bounce: getBounceData(bounceData)
1014
- }, actions), callbacks), {
1015
- refetch
1016
- });
1017
- };
1018
-
1019
- // src/hooks/use-fetch/use-fetch.utils.ts
1020
- var getRefreshTime = (refreshTime, dataTimestamp) => {
1021
- if (dataTimestamp) {
1022
- const timeDiff = Date.now() - +dataTimestamp;
1023
- return timeDiff < refreshTime ? refreshTime - timeDiff : refreshTime;
1024
- }
1025
- return refreshTime;
1026
- };
1027
-
1028
- // src/hooks/use-fetch/use-fetch.constants.ts
1029
- var import_core2 = require("@hyper-fetch/core");
1030
- var useFetchDefaultOptions = {
1031
- dependencies: [],
1032
- disabled: false,
1033
- dependencyTracking: true,
1034
- revalidate: true,
1035
- initialData: null,
1036
- refresh: false,
1037
- refreshTime: import_core2.DateInterval.hour,
1038
- refetchBlurred: true,
1039
- refetchOnBlur: false,
1040
- refetchOnFocus: false,
1041
- refetchOnReconnect: false,
1042
- bounce: false,
1043
- bounceType: "debounce",
1044
- bounceTime: 400,
1045
- deepCompare: true
1046
- };
1047
-
1048
- // src/hooks/use-submit/use-submit.hooks.ts
1049
- var import_react6 = require("react");
1050
- var import_core3 = require("@hyper-fetch/core");
1051
- var import_lifecycle5 = require("@better-hooks/lifecycle");
1052
- var import_performance2 = require("@better-hooks/performance");
1053
- var useSubmit = (request, options = useSubmitDefaultOptions) => {
1054
- const [globalConfig] = useConfigProvider();
1055
- const mergedOptions = (0, import_react6.useMemo)(
1056
- () => __spreadValues(__spreadValues(__spreadValues({}, useSubmitDefaultOptions), globalConfig.useSubmitConfig), options),
1057
- [globalConfig.useSubmitConfig, JSON.stringify(options), options.deepCompare]
1058
- );
1059
- const { disabled, dependencyTracking, initialData, bounce, bounceType, bounceTime, deepCompare } = mergedOptions;
1060
- const { client } = request;
1061
- const { cache, submitDispatcher: dispatcher, loggerManager } = client;
1062
- const logger = (0, import_react6.useRef)(loggerManager.init("useSubmit")).current;
1063
- const requestDebounce = (0, import_performance2.useDebounce)({ delay: bounceTime });
1064
- const requestThrottle = (0, import_performance2.useThrottle)({
1065
- interval: bounceTime,
1066
- timeout: "bounceTimeout" in mergedOptions ? mergedOptions.bounceTimeout : bounceTime
1067
- });
1068
- const bounceResolver = (0, import_react6.useRef)(() => null);
1069
- const bounceData = bounceType === "throttle" ? requestThrottle : requestDebounce;
1070
- const bounceFunction = bounceType === "throttle" ? requestThrottle.throttle : requestDebounce.debounce;
1071
- const [state, actions, { setRenderKey, setCacheData, getIsDataProcessing }] = useTrackedState({
1072
- logger,
1073
- request,
1074
- dispatcher,
1075
- initialData,
1076
- deepCompare,
1077
- dependencyTracking
1078
- });
1079
- const [callbacks, listeners] = useRequestEvents({
1080
- logger,
1081
- actions,
1082
- request,
1083
- dispatcher,
1084
- setCacheData,
1085
- getIsDataProcessing
1086
- });
1087
- const { addCacheDataListener, addLifecycleListeners } = listeners;
1088
- const handleSubmit = (submitOptions) => {
1089
- const requestClone = request.clone(submitOptions);
1090
- if (disabled) {
1091
- logger.warning(`Cannot submit request`, { disabled, submitOptions });
1092
- return Promise.resolve({
1093
- data: null,
1094
- error: new Error("Cannot submit request. Option 'disabled' is enabled"),
1095
- status: null,
1096
- extra: request.client.defaultExtra
1097
- });
1098
- }
1099
- const triggerRequest = () => {
1100
- addCacheDataListener(requestClone);
1101
- return (0, import_core3.sendRequest)(requestClone, __spreadProps(__spreadValues({
1102
- dispatcherType: "submit"
1103
- }, submitOptions), {
1104
- onSettle: (requestId, cmd) => {
1105
- var _a;
1106
- addLifecycleListeners(requestClone, requestId);
1107
- (_a = submitOptions == null ? void 0 : submitOptions.onSettle) == null ? void 0 : _a.call(submitOptions, requestId, cmd);
1108
- }
1109
- }));
1110
- };
1111
- return new Promise((resolve) => {
1112
- const performSubmit = () => __async(void 0, null, function* () {
1113
- logger.debug(`Submitting request`, { disabled, submitOptions });
1114
- if (bounce) {
1115
- const bouncedResolve = bounceResolver.current;
1116
- bounceResolver.current = (value) => {
1117
- bouncedResolve(value);
1118
- resolve(value);
1119
- };
1120
- bounceFunction(() => __async(void 0, null, function* () {
1121
- const callback = bounceResolver.current;
1122
- bounceResolver.current = () => null;
1123
- const value = yield triggerRequest();
1124
- callback(value);
1125
- }));
1126
- } else {
1127
- const value = yield triggerRequest();
1128
- resolve(value);
1129
- }
1130
- });
1131
- performSubmit();
1132
- });
1133
- };
1134
- const handleInvalidation = (invalidateKey) => {
1135
- if (invalidateKey && invalidateKey instanceof import_core3.Request) {
1136
- cache.invalidate((0, import_core3.getRequestKey)(invalidateKey));
1137
- } else if (invalidateKey && !(invalidateKey instanceof import_core3.Request)) {
1138
- cache.invalidate(invalidateKey);
1139
- }
1140
- };
1141
- const refetch = (invalidateKey) => {
1142
- if (!invalidateKey)
1143
- return;
1144
- if (invalidateKey && Array.isArray(invalidateKey)) {
1145
- invalidateKey.forEach(handleInvalidation);
1146
- } else if (invalidateKey && !Array.isArray(invalidateKey)) {
1147
- handleInvalidation(invalidateKey);
1148
- }
1149
- };
1150
- const handlers = {
1151
- onSubmitSuccess: callbacks.onSuccess,
1152
- onSubmitError: callbacks.onError,
1153
- onSubmitFinished: callbacks.onFinished,
1154
- onSubmitRequestStart: callbacks.onRequestStart,
1155
- onSubmitResponseStart: callbacks.onResponseStart,
1156
- onSubmitDownloadProgress: callbacks.onDownloadProgress,
1157
- onSubmitUploadProgress: callbacks.onUploadProgress,
1158
- onSubmitOfflineError: callbacks.onOfflineError,
1159
- onSubmitAbort: callbacks.onAbort
1160
- };
1161
- (0, import_lifecycle5.useDidMount)(() => {
1162
- addCacheDataListener(request);
1163
- });
1164
- return __spreadProps(__spreadValues(__spreadValues({
1165
- submit: handleSubmit,
1166
- get data() {
1167
- setRenderKey("data");
1168
- return state.data;
1169
- },
1170
- get error() {
1171
- setRenderKey("error");
1172
- return state.error;
1173
- },
1174
- get submitting() {
1175
- setRenderKey("loading");
1176
- return state.loading;
1177
- },
1178
- get status() {
1179
- setRenderKey("status");
1180
- return state.status;
1181
- },
1182
- get success() {
1183
- setRenderKey("success");
1184
- return state.success;
1185
- },
1186
- get extra() {
1187
- setRenderKey("extra");
1188
- return state.extra;
1189
- },
1190
- get retries() {
1191
- setRenderKey("retries");
1192
- return state.retries;
1193
- },
1194
- get timestamp() {
1195
- setRenderKey("timestamp");
1196
- return state.timestamp;
1197
- },
1198
- abort: callbacks.abort
1199
- }, actions), handlers), {
1200
- bounce: getBounceData(bounceData),
1201
- refetch
1202
- });
1203
- };
1204
-
1205
- // src/hooks/use-submit/use-submit.constants.ts
1206
- var useSubmitDefaultOptions = {
1207
- disabled: false,
1208
- dependencyTracking: true,
1209
- initialData: null,
1210
- bounce: false,
1211
- bounceType: "debounce",
1212
- bounceTime: 400,
1213
- deepCompare: true
1214
- };
1215
-
1216
- // src/hooks/use-queue/use-queue.hooks.ts
1217
- var import_react7 = require("react");
1218
- var import_core4 = require("@hyper-fetch/core");
1219
- var import_lifecycle6 = require("@better-hooks/lifecycle");
1220
- var useQueue = (request, options = useQueueDefaultOptions) => {
1221
- const [globalConfig] = useConfigProvider();
1222
- const { queueType = "auto" } = __spreadValues(__spreadValues(__spreadValues({}, useQueueDefaultOptions), globalConfig.useQueueConfig), options);
1223
- const { abortKey, queueKey, client } = request;
1224
- const { requestManager } = client;
1225
- const [dispatcher] = (0, import_core4.getRequestDispatcher)(request, queueType);
1226
- const unmountCallbacks = (0, import_react7.useRef)(null);
1227
- const [stopped, setStopped] = (0, import_react7.useState)(false);
1228
- const [requests, setRequests] = (0, import_react7.useState)([]);
1229
- const createRequestsArray = (queueElements) => {
1230
- return queueElements.map((req) => __spreadProps(__spreadValues({}, req), {
1231
- stopRequest: () => dispatcher.stopRequest(queueKey, req.requestId),
1232
- startRequest: () => dispatcher.startRequest(queueKey, req.requestId),
1233
- deleteRequest: () => dispatcher.delete(queueKey, req.requestId, abortKey)
1234
- }));
1235
- };
1236
- const mergePayloadType = (requestId, data) => {
1237
- setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadValues(__spreadValues({}, el), data) : el));
1238
- };
1239
- const getInitialState2 = () => {
1240
- const requestQueue = dispatcher.getQueue(queueKey);
1241
- setStopped(requestQueue.stopped);
1242
- setRequests(createRequestsArray(requestQueue.requests));
1243
- };
1244
- const updateQueueState = (values) => {
1245
- setStopped(values.stopped);
1246
- setRequests(createRequestsArray(values.requests));
1247
- };
1248
- const mountEvents = () => {
1249
- var _a;
1250
- const unmountChange = dispatcher.events.onQueueChange(queueKey, updateQueueState);
1251
- const unmountStatus = dispatcher.events.onQueueStatus(queueKey, updateQueueState);
1252
- const unmountDownload = requestManager.events.onDownloadProgress(queueKey, (progress, { requestId }) => {
1253
- mergePayloadType(requestId, { downloading: progress });
1254
- });
1255
- const unmountUpload = requestManager.events.onUploadProgress(queueKey, (progress, { requestId }) => {
1256
- mergePayloadType(requestId, { uploading: progress });
1257
- });
1258
- const unmount = () => {
1259
- unmountStatus();
1260
- unmountChange();
1261
- unmountDownload();
1262
- unmountUpload();
1263
- };
1264
- (_a = unmountCallbacks.current) == null ? void 0 : _a.call(unmountCallbacks);
1265
- unmountCallbacks.current = unmount;
1266
- return unmount;
1267
- };
1268
- (0, import_lifecycle6.useDidMount)(getInitialState2);
1269
- (0, import_lifecycle6.useDidUpdate)(mountEvents, [stopped, requests, setRequests, setStopped], true);
1270
- return {
1271
- stopped,
1272
- requests,
1273
- stop: () => dispatcher.stop(queueKey),
1274
- pause: () => dispatcher.pause(queueKey),
1275
- start: () => dispatcher.start(queueKey)
1276
- };
1277
- };
1278
-
1279
- // src/hooks/use-queue/use-queue.constants.ts
1280
- var useQueueDefaultOptions = {
1281
- queueType: "auto"
1282
- };
1283
-
1284
- // src/hooks/use-cache/use-cache.hooks.ts
1285
- var import_react8 = require("react");
1286
- var import_lifecycle7 = require("@better-hooks/lifecycle");
1287
- var import_core5 = require("@hyper-fetch/core");
1288
- var useCache = (request, options = useCacheDefaultOptions) => {
1289
- const { cacheKey, client } = request;
1290
- const { cache, loggerManager } = client;
1291
- const logger = (0, import_react8.useRef)(loggerManager.init("useCache")).current;
1292
- const [dispatcher] = (0, import_core5.getRequestDispatcher)(request);
1293
- const updateKey = JSON.stringify(request.toJSON());
1294
- const [globalConfig] = useConfigProvider();
1295
- const { dependencyTracking, initialData, deepCompare } = __spreadValues(__spreadValues(__spreadValues({}, useCacheDefaultOptions), globalConfig.useCacheConfig), options);
1296
- const [state, actions, { setRenderKey, setCacheData, getIsDataProcessing }] = useTrackedState({
1297
- logger,
1298
- request,
1299
- dispatcher,
1300
- initialData,
1301
- deepCompare,
1302
- dependencyTracking
1303
- });
1304
- const [callbacks, listeners] = useRequestEvents({
1305
- logger,
1306
- actions,
1307
- request,
1308
- dispatcher,
1309
- setCacheData,
1310
- getIsDataProcessing
1311
- });
1312
- const { addCacheDataListener, addLifecycleListeners } = listeners;
1313
- const handleMountEvents = () => {
1314
- addCacheDataListener(request);
1315
- addLifecycleListeners(request);
1316
- };
1317
- (0, import_lifecycle7.useDidUpdate)(handleMountEvents, [updateKey], true);
1318
- const refetch = (invalidateKey) => {
1319
- if (invalidateKey instanceof import_core5.Request) {
1320
- cache.invalidate((0, import_core5.getRequestKey)(invalidateKey, true));
1321
- } else if (invalidateKey) {
1322
- cache.invalidate(invalidateKey);
1323
- } else {
1324
- cache.invalidate(cacheKey);
1325
- }
1326
- };
1327
- return __spreadProps(__spreadValues({
1328
- get data() {
1329
- setRenderKey("data");
1330
- return state.data;
1331
- },
1332
- get error() {
1333
- setRenderKey("error");
1334
- return state.error;
1335
- },
1336
- get loading() {
1337
- setRenderKey("loading");
1338
- return state.loading;
1339
- },
1340
- get status() {
1341
- setRenderKey("status");
1342
- return state.status;
1343
- },
1344
- get success() {
1345
- setRenderKey("success");
1346
- return state.success;
1347
- },
1348
- get extra() {
1349
- setRenderKey("extra");
1350
- return state.extra;
1351
- },
1352
- get retries() {
1353
- setRenderKey("retries");
1354
- return state.retries;
1355
- },
1356
- get timestamp() {
1357
- setRenderKey("timestamp");
1358
- return state.timestamp;
1359
- },
1360
- onCacheError: callbacks.onError,
1361
- onCacheSuccess: callbacks.onSuccess,
1362
- onCacheChange: callbacks.onFinished
1363
- }, actions), {
1364
- refetch
1365
- });
1366
- };
1367
-
1368
- // src/hooks/use-cache/use-cache.constants.ts
1369
- var useCacheDefaultOptions = {
1370
- dependencyTracking: true,
1371
- initialData: null,
1372
- deepCompare: true
1373
- };
1374
-
1375
- // src/hooks/use-listener/use-listener.hooks.ts
1376
- var import_react9 = require("react");
1377
- var import_lifecycle8 = require("@better-hooks/lifecycle");
1378
- var useListener = (listener, options) => {
1379
- const [globalConfig] = useConfigProvider();
1380
- const { dependencyTracking } = __spreadValues(__spreadValues({}, globalConfig.useListener), options);
1381
- const [state, actions, callbacks, { setRenderKey }] = useSocketState(listener.socket, { dependencyTracking });
1382
- const removeListenerRef = (0, import_react9.useRef)(null);
1383
- const onEventCallback = (0, import_react9.useRef)(null);
1384
- const stopListener = () => {
1385
- var _a;
1386
- (_a = removeListenerRef.current) == null ? void 0 : _a.call(removeListenerRef);
1387
- };
1388
- const listen = () => {
1389
- stopListener();
1390
- removeListenerRef.current = listener.listen({
1391
- callback: ({ data, extra }) => {
1392
- var _a;
1393
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, { data, extra });
1394
- actions.setData(data);
1395
- actions.setTimestamp(+new Date());
1396
- }
1397
- });
1398
- };
1399
- const additionalCallbacks = {
1400
- onEvent: (callback) => {
1401
- onEventCallback.current = callback;
1402
- }
1403
- };
1404
- (0, import_lifecycle8.useDidUpdate)(
1405
- () => {
1406
- listen();
1407
- },
1408
- [listener.params, JSON.stringify(listener.options)],
1409
- true
1410
- );
1411
- (0, import_lifecycle8.useWillUnmount)(() => {
1412
- stopListener();
1413
- });
1414
- return __spreadProps(__spreadValues(__spreadValues(__spreadValues({
1415
- get data() {
1416
- setRenderKey("data");
1417
- return state.data;
1418
- },
1419
- get connected() {
1420
- setRenderKey("connected");
1421
- return state.connected;
1422
- },
1423
- get connecting() {
1424
- setRenderKey("connecting");
1425
- return state.connecting;
1426
- },
1427
- get timestamp() {
1428
- setRenderKey("timestamp");
1429
- return state.timestamp;
1430
- }
1431
- }, actions), callbacks), additionalCallbacks), {
1432
- listen
1433
- });
1434
- };
1435
-
1436
- // src/hooks/use-emitter/use-emitter.hooks.ts
1437
- var import_react10 = require("react");
1438
- var useEmitter = (emitter, options) => {
1439
- const [globalConfig] = useConfigProvider();
1440
- const { dependencyTracking } = __spreadValues(__spreadValues({}, globalConfig.useEmitter), options);
1441
- const onEventCallback = (0, import_react10.useRef)(null);
1442
- const [state, actions, callbacks, { setRenderKey }] = useSocketState(emitter.socket, { dependencyTracking });
1443
- const additionalCallbacks = {
1444
- onEvent: (callback) => {
1445
- onEventCallback.current = callback;
1446
- }
1447
- };
1448
- const emit = (emitOptions) => {
1449
- var _a;
1450
- actions.setTimestamp(+new Date());
1451
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, emitter);
1452
- return emitter.emit(emitOptions);
1453
- };
1454
- return __spreadProps(__spreadValues(__spreadValues(__spreadValues({
1455
- get connected() {
1456
- setRenderKey("connected");
1457
- return state.connected;
1458
- },
1459
- get connecting() {
1460
- setRenderKey("connecting");
1461
- return state.connecting;
1462
- },
1463
- get timestamp() {
1464
- setRenderKey("timestamp");
1465
- return state.timestamp;
1466
- }
1467
- }, actions), callbacks), additionalCallbacks), {
1468
- emit,
1469
- reconnect: emitter.socket.reconnect
1470
- });
1471
- };
1472
-
1473
- // src/hooks/use-event-messages/use-event-messages.hooks.ts
1474
- var import_react11 = require("react");
1475
- var import_lifecycle9 = require("@better-hooks/lifecycle");
1476
- var useEventMessages = (socket, options) => {
1477
- const [globalConfig] = useConfigProvider();
1478
- const { dependencyTracking = false, filter } = __spreadValues(__spreadValues({}, globalConfig.useEventMessages), options);
1479
- const onEventCallback = (0, import_react11.useRef)(null);
1480
- const [state, actions, callbacks, { setRenderKey }] = useSocketState(socket, { dependencyTracking });
1481
- (0, import_lifecycle9.useDidUpdate)(
1482
- () => {
1483
- const unmountListener = socket.events.onListenerEvent(({ endpoint, data, extra }) => {
1484
- var _a;
1485
- const filterFn = typeof filter === "function" ? () => filter(endpoint, data) : () => filter.includes(endpoint);
1486
- const isFiltered = filter ? filterFn() : false;
1487
- if (!isFiltered) {
1488
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, data, extra);
1489
- actions.setData(data);
1490
- actions.setTimestamp(+new Date());
1491
- }
1492
- });
1493
- return unmountListener;
1494
- },
1495
- [socket, filter],
1496
- true
1497
- );
1498
- const additionalCallbacks = {
1499
- onEvent: (callback) => {
1500
- onEventCallback.current = callback;
1501
- }
1502
- };
1503
- return __spreadValues(__spreadValues(__spreadValues({
1504
- get data() {
1505
- setRenderKey("data");
1506
- return state.data;
1507
- },
1508
- get connected() {
1509
- setRenderKey("connected");
1510
- return state.connected;
1511
- },
1512
- get connecting() {
1513
- setRenderKey("connecting");
1514
- return state.connecting;
1515
- },
1516
- get timestamp() {
1517
- setRenderKey("timestamp");
1518
- return state.timestamp;
1519
- }
1520
- }, actions), callbacks), additionalCallbacks);
1521
- };
1522
-
1523
- // src/hooks/use-app-manager/use-app-manager.hooks.ts
1524
- var import_react12 = require("react");
1525
- var import_lifecycle10 = require("@better-hooks/lifecycle");
1526
- var useAppManager = (client) => {
1527
- const [online, setIsOnline] = (0, import_react12.useState)(client.appManager.isOnline);
1528
- const [focused, setIsFocused] = (0, import_react12.useState)(client.appManager.isFocused);
1529
- const mountEvents = () => {
1530
- const unmountIsOnline = client.appManager.events.onOnline(() => setIsOnline(true));
1531
- const unmountIsOffline = client.appManager.events.onOffline(() => setIsOnline(false));
1532
- const unmountIsFocus = client.appManager.events.onFocus(() => setIsFocused(true));
1533
- const unmountIsBlur = client.appManager.events.onBlur(() => setIsFocused(false));
1534
- return () => {
1535
- unmountIsOnline();
1536
- unmountIsOffline();
1537
- unmountIsFocus();
1538
- unmountIsBlur();
1539
- };
1540
- };
1541
- const setOnline = (isOnline) => {
1542
- client.appManager.setOnline(isOnline);
1543
- };
1544
- const setFocused = (isFocused) => {
1545
- client.appManager.setFocused(isFocused);
1546
- };
1547
- (0, import_lifecycle10.useDidMount)(mountEvents);
1548
- return { isOnline: online, isFocused: focused, setOnline, setFocused };
1549
- };
1550
- //# sourceMappingURL=index.cjs.js.map