@hyper-fetch/react 6.0.1 → 7.0.0

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} +460 -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 +73 -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 +69 -113
  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 +41 -40
  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
@@ -39,14 +39,13 @@ var __async = (__this, __arguments, generator) => {
39
39
  };
40
40
 
41
41
  // src/hooks/use-fetch/use-fetch.hooks.ts
42
- import { useRef as useRef4 } from "react";
43
42
  import { useDidUpdate as useDidUpdate3, useDidMount as useDidMount2, useWillUnmount as useWillUnmount2 } from "@better-hooks/lifecycle";
44
43
  import { useDebounce, useThrottle } from "@better-hooks/performance";
45
- import { Request, getRequestKey } from "@hyper-fetch/core";
44
+ import { useRef as useRef4 } from "react";
46
45
 
47
46
  // src/helpers/use-request-events/use-request-events.hooks.ts
48
- import { useRef } from "react";
49
47
  import { useWillUnmount } from "@better-hooks/lifecycle";
48
+ import { useRef } from "react";
50
49
  var useRequestEvents = ({
51
50
  request,
52
51
  dispatcher,
@@ -55,7 +54,7 @@ var useRequestEvents = ({
55
54
  setCacheData,
56
55
  getIsDataProcessing
57
56
  }) => {
58
- const { responseMapper } = request;
57
+ const { unstable_responseMapper } = request;
59
58
  const { cache, requestManager } = request.client;
60
59
  const onSuccessCallback = useRef(null);
61
60
  const onErrorCallback = useRef(null);
@@ -81,66 +80,65 @@ var useRequestEvents = ({
81
80
  });
82
81
  events.clear();
83
82
  };
84
- const handleResponseCallbacks = (cmd, response, details) => {
83
+ const handleResponseCallbacks = (values) => {
85
84
  var _a, _b, _c, _d, _e;
86
- const { data, error, success } = response;
87
- const { isOffline, isCanceled } = details;
85
+ const { success } = values.response;
86
+ const { isOffline, isCanceled } = values.details;
88
87
  if (request.offline && isOffline && !success) {
89
- logger.debug("Performing offline error callback", { data, details });
90
- (_a = onOfflineErrorCallback.current) == null ? void 0 : _a.call(onOfflineErrorCallback, { response: error, request: cmd, details });
88
+ logger.debug({ title: "Performing offline error callback", type: "system", extra: values });
89
+ (_a = onOfflineErrorCallback.current) == null ? void 0 : _a.call(onOfflineErrorCallback, values);
91
90
  } else if (isCanceled) {
92
- logger.debug("Performing abort callback", { data, details });
93
- (_b = onAbortCallback.current) == null ? void 0 : _b.call(onAbortCallback, { response: error, request: cmd, details });
91
+ logger.debug({ title: "Performing abort callback", type: "system", extra: values });
92
+ (_b = onAbortCallback.current) == null ? void 0 : _b.call(onAbortCallback, values);
94
93
  } else if (success) {
95
- logger.debug("Performing success callback", { data, details });
96
- (_c = onSuccessCallback.current) == null ? void 0 : _c.call(onSuccessCallback, { response: data, request: cmd, details });
94
+ logger.debug({ title: "Performing success callback", type: "system", extra: values });
95
+ (_c = onSuccessCallback.current) == null ? void 0 : _c.call(onSuccessCallback, values);
97
96
  } else {
98
- logger.debug("Performing error callback", { data, details });
99
- (_d = onErrorCallback.current) == null ? void 0 : _d.call(onErrorCallback, { response: error, request: cmd, details });
97
+ logger.debug({ title: "Performing error callback", type: "system", extra: values });
98
+ (_d = onErrorCallback.current) == null ? void 0 : _d.call(onErrorCallback, values);
100
99
  }
101
- (_e = onFinishedCallback.current) == null ? void 0 : _e.call(onFinishedCallback, { response, request: cmd, details });
100
+ (_e = onFinishedCallback.current) == null ? void 0 : _e.call(onFinishedCallback, values);
102
101
  };
103
102
  const handleGetLoadingEvent = (req) => {
104
103
  return ({ loading }) => {
105
104
  const isProcessing = getIsDataProcessing(req.cacheKey);
106
105
  if (isProcessing)
107
106
  return;
108
- const canDisableLoading = !loading && !dispatcher.hasRunningRequests(req.queueKey);
107
+ const canDisableLoading = !loading && !dispatcher.hasRunningRequests(req.queryKey);
109
108
  if (loading || canDisableLoading) {
110
- actions.setLoading(loading, false);
109
+ actions.setLoading(loading);
111
110
  }
112
111
  };
113
112
  };
114
- const handleDownloadProgress = (progress, details) => {
113
+ const handleDownloadProgress = (data) => {
115
114
  var _a;
116
- (_a = onDownloadProgressCallback.current) == null ? void 0 : _a.call(onDownloadProgressCallback, progress, details);
115
+ (_a = onDownloadProgressCallback.current) == null ? void 0 : _a.call(onDownloadProgressCallback, data);
117
116
  };
118
- const handleUploadProgress = (progress, details) => {
117
+ const handleUploadProgress = (data) => {
119
118
  var _a;
120
- (_a = onUploadProgressCallback.current) == null ? void 0 : _a.call(onUploadProgressCallback, progress, details);
119
+ (_a = onUploadProgressCallback.current) == null ? void 0 : _a.call(onUploadProgressCallback, data);
121
120
  };
122
- const handleRequestStart = (cmd) => {
121
+ const handleRequestStart = () => {
123
122
  return (details) => {
124
123
  var _a;
125
- (_a = onRequestStartCallback.current) == null ? void 0 : _a.call(onRequestStartCallback, { request: cmd, details });
124
+ (_a = onRequestStartCallback.current) == null ? void 0 : _a.call(onRequestStartCallback, details);
126
125
  };
127
126
  };
128
- const handleResponseStart = (cmd) => {
127
+ const handleResponseStart = () => {
129
128
  return (details) => {
130
129
  var _a;
131
- (_a = onResponseStartCallback.current) == null ? void 0 : _a.call(onResponseStartCallback, { request: cmd, details });
130
+ (_a = onResponseStartCallback.current) == null ? void 0 : _a.call(onResponseStartCallback, details);
132
131
  };
133
132
  };
134
- const handleResponse = (req) => {
135
- return (response, details) => {
136
- const data = responseMapper ? responseMapper(response) : response;
133
+ const handleResponse = () => {
134
+ return (values) => {
135
+ const data = unstable_responseMapper ? unstable_responseMapper(values.response) : values.response;
137
136
  if (data instanceof Promise) {
138
137
  return (() => __async(void 0, null, function* () {
139
- const promiseData = yield data;
140
- handleResponseCallbacks(req, promiseData, details);
138
+ handleResponseCallbacks(__spreadProps(__spreadValues({}, values), { response: yield data }));
141
139
  }))();
142
140
  }
143
- return handleResponseCallbacks(req, data, details);
141
+ return handleResponseCallbacks(values);
144
142
  };
145
143
  };
146
144
  const handleRemove = ({ requestId }) => {
@@ -152,11 +150,8 @@ var useRequestEvents = ({
152
150
  dataEvents.current = null;
153
151
  };
154
152
  const addCacheDataListener = (req) => {
155
- const loadingUnmount = requestManager.events.onLoading(req.queueKey, handleGetLoadingEvent(req));
156
- const getResponseUnmount = cache.events.onData(
157
- req.cacheKey,
158
- setCacheData
159
- );
153
+ const loadingUnmount = requestManager.events.onLoadingByQueue(req.queryKey, handleGetLoadingEvent(req));
154
+ const getResponseUnmount = cache.events.onDataByKey(req.cacheKey, setCacheData);
160
155
  const unmount = () => {
161
156
  loadingUnmount();
162
157
  getResponseUnmount();
@@ -168,12 +163,12 @@ var useRequestEvents = ({
168
163
  const addLifecycleListeners = (req, requestId) => {
169
164
  if (!requestId) {
170
165
  clearLifecycleListeners();
171
- const { queueKey, cacheKey } = req;
172
- const requestStartUnmount2 = requestManager.events.onRequestStart(queueKey, handleRequestStart(req));
173
- const responseStartUnmount2 = requestManager.events.onResponseStart(queueKey, handleResponseStart(req));
174
- const uploadUnmount2 = requestManager.events.onUploadProgress(queueKey, handleUploadProgress);
175
- const downloadUnmount2 = requestManager.events.onDownloadProgress(queueKey, handleDownloadProgress);
176
- const responseUnmount2 = requestManager.events.onResponse(cacheKey, handleResponse(req));
166
+ const { queryKey, cacheKey } = req;
167
+ const requestStartUnmount2 = requestManager.events.onRequestStartByQueue(queryKey, handleRequestStart());
168
+ const responseStartUnmount2 = requestManager.events.onResponseStartByQueue(queryKey, handleResponseStart());
169
+ const uploadUnmount2 = requestManager.events.onUploadProgressByQueue(queryKey, handleUploadProgress);
170
+ const downloadUnmount2 = requestManager.events.onDownloadProgressByQueue(queryKey, handleDownloadProgress);
171
+ const responseUnmount2 = requestManager.events.onResponseByCache(cacheKey, handleResponse());
177
172
  const unmount2 = () => {
178
173
  downloadUnmount2();
179
174
  uploadUnmount2();
@@ -181,13 +176,13 @@ var useRequestEvents = ({
181
176
  responseStartUnmount2();
182
177
  responseUnmount2();
183
178
  };
184
- lifecycleEvents.current.set(queueKey, { unmount: unmount2 });
179
+ lifecycleEvents.current.set(queryKey, { unmount: unmount2 });
185
180
  return unmount2;
186
181
  }
187
182
  const requestRemove = requestManager.events.onRemoveById(requestId, handleRemove);
188
- const requestStartUnmount = requestManager.events.onRequestStartById(requestId, handleRequestStart(req));
189
- const responseStartUnmount = requestManager.events.onResponseStartById(requestId, handleResponseStart(req));
190
- const responseUnmount = requestManager.events.onResponseById(requestId, handleResponse(req));
183
+ const requestStartUnmount = requestManager.events.onRequestStartById(requestId, handleRequestStart());
184
+ const responseStartUnmount = requestManager.events.onResponseStartById(requestId, handleResponseStart());
185
+ const responseUnmount = requestManager.events.onResponseById(requestId, handleResponse());
191
186
  const uploadUnmount = requestManager.events.onUploadProgressById(requestId, handleUploadProgress);
192
187
  const downloadUnmount = requestManager.events.onDownloadProgressById(requestId, handleDownloadProgress);
193
188
  const unmount = () => {
@@ -203,10 +198,10 @@ var useRequestEvents = ({
203
198
  };
204
199
  const abort = () => {
205
200
  const { abortKey } = request;
206
- const requests = dispatcher.getAllRunningRequest();
201
+ const requests = dispatcher.getAllRunningRequests();
207
202
  requests.forEach((requestData) => {
208
203
  if (requestData.request.abortKey === abortKey) {
209
- dispatcher.delete(requestData.request.queueKey, requestData.requestId, abortKey);
204
+ dispatcher.delete(requestData.request.queryKey, requestData.requestId, abortKey);
210
205
  }
211
206
  });
212
207
  };
@@ -260,16 +255,17 @@ var initialState = {
260
255
  data: null,
261
256
  error: null,
262
257
  status: null,
263
- extra: null,
264
- success: null,
258
+ extra: {},
259
+ success: false,
265
260
  loading: false,
266
261
  retries: 0,
267
- timestamp: null
262
+ responseTimestamp: null,
263
+ requestTimestamp: null
268
264
  };
269
265
 
270
266
  // src/helpers/use-tracked-state/use-tracked-state.hooks.ts
271
- import { useRef as useRef2 } from "react";
272
267
  import { useDidUpdate, useForceUpdate } from "@better-hooks/lifecycle";
268
+ import { useRef as useRef2 } from "react";
273
269
 
274
270
  // src/utils/deep-equal.utils.ts
275
271
  var isEmpty = (value) => {
@@ -292,8 +288,6 @@ var isEqual = (firstValue, secondValue) => {
292
288
  const isTypeValue = (type) => firstValueType === type && secondValueType === type;
293
289
  if (firstValueType !== secondValueType)
294
290
  return false;
295
- if (firstValue === null && secondValue === null)
296
- return true;
297
291
  if (isType("number") && Number.isNaN(firstValue) && Number.isNaN(secondValue))
298
292
  return true;
299
293
  if (isEmpty(firstValue) && isEmpty(secondValue))
@@ -329,32 +323,40 @@ var getBounceData = (bounceData) => {
329
323
  var getDetailsState = (state, details) => {
330
324
  return __spreadValues({
331
325
  retries: (state == null ? void 0 : state.retries) || 0,
332
- timestamp: +new Date(),
333
326
  isCanceled: false,
334
- isOffline: false
327
+ isOffline: false,
328
+ addedTimestamp: +/* @__PURE__ */ new Date(),
329
+ triggerTimestamp: +/* @__PURE__ */ new Date(),
330
+ requestTimestamp: +/* @__PURE__ */ new Date(),
331
+ responseTimestamp: +/* @__PURE__ */ new Date()
335
332
  }, details);
336
333
  };
337
- var isStaleCacheData = (cacheTime, cacheTimestamp) => {
338
- if (!cacheTimestamp)
334
+ var isStaleCacheData = (staleTime, staleTimestamp) => {
335
+ if (!staleTimestamp)
339
336
  return true;
340
- return +new Date() > +cacheTimestamp + cacheTime;
337
+ return +/* @__PURE__ */ new Date() > +staleTimestamp + staleTime;
341
338
  };
342
- var getValidCacheData = (request, initialData, cacheData) => {
343
- const isStale = isStaleCacheData(request.cacheTime, cacheData == null ? void 0 : cacheData.timestamp);
339
+ var getValidCacheData = (request, initialResponse, cacheData) => {
340
+ var _a, _b;
341
+ const isStale = isStaleCacheData(request.staleTime, cacheData == null ? void 0 : cacheData.responseTimestamp);
344
342
  if (!isStale && cacheData) {
345
343
  return cacheData;
346
344
  }
347
- if (initialData) {
345
+ if (initialResponse) {
348
346
  return __spreadProps(__spreadValues(__spreadValues({
349
347
  data: null,
350
348
  error: null,
351
349
  status: null,
352
- success: null,
353
- extra: null
354
- }, initialData || {}), getDetailsState()), {
355
- cacheTime: 1e3,
356
- clearKey: request.client.cache.clearKey,
357
- garbageCollection: request.garbageCollection
350
+ success: true,
351
+ extra: null,
352
+ cached: !!request.cache
353
+ }, initialResponse), getDetailsState()), {
354
+ staleTime: 1e3,
355
+ version: request.client.cache.version,
356
+ cacheKey: request.cacheKey,
357
+ cacheTime: request.cacheTime,
358
+ requestTimestamp: (_a = initialResponse == null ? void 0 : initialResponse.requestTimestamp) != null ? _a : +/* @__PURE__ */ new Date(),
359
+ responseTimestamp: (_b = initialResponse == null ? void 0 : initialResponse.responseTimestamp) != null ? _b : +/* @__PURE__ */ new Date()
358
360
  });
359
361
  }
360
362
  return null;
@@ -383,19 +385,19 @@ var getInitialState = ({
383
385
  disabled,
384
386
  revalidate
385
387
  }) => {
386
- const { client, cacheKey, responseMapper } = request;
388
+ const { client, cacheKey, unstable_responseMapper } = request;
387
389
  const { cache } = client;
388
390
  const cacheData = cache.get(cacheKey);
389
391
  const cacheState = getValidCacheData(request, initialResponse, cacheData);
390
392
  const initialLoading = getIsInitiallyLoading({
391
- queryKey: request.queueKey,
393
+ queryKey: request.queryKey,
392
394
  dispatcher,
393
395
  disabled,
394
396
  revalidate,
395
397
  hasState: !!cacheState
396
398
  });
397
399
  if (cacheState) {
398
- const mappedData = responseMapper ? responseMapper(cacheState) : cacheState;
400
+ const mappedData = unstable_responseMapper ? unstable_responseMapper(cacheState) : cacheState;
399
401
  if (mappedData instanceof Promise) {
400
402
  return initialState;
401
403
  }
@@ -404,9 +406,10 @@ var getInitialState = ({
404
406
  error: mappedData.error,
405
407
  status: mappedData.status,
406
408
  success: mappedData.success,
407
- extra: mappedData.extra,
409
+ extra: mappedData.extra || client.adapter.defaultExtra,
408
410
  retries: cacheState.retries,
409
- timestamp: getTimestamp(cacheState.timestamp),
411
+ requestTimestamp: getTimestamp(cacheState.requestTimestamp),
412
+ responseTimestamp: getTimestamp(cacheState.responseTimestamp),
410
413
  loading: initialLoading
411
414
  };
412
415
  }
@@ -415,9 +418,10 @@ var getInitialState = ({
415
418
  error: initialState.error,
416
419
  status: initialState.status,
417
420
  success: initialState.success,
418
- extra: request.client.defaultExtra,
421
+ extra: request.client.adapter.defaultExtra,
419
422
  retries: initialState.retries,
420
- timestamp: getTimestamp(initialState.timestamp),
423
+ requestTimestamp: getTimestamp(initialState.requestTimestamp),
424
+ responseTimestamp: getTimestamp(initialState.responseTimestamp),
421
425
  loading: initialLoading
422
426
  };
423
427
  };
@@ -426,24 +430,21 @@ var getInitialState = ({
426
430
  var useTrackedState = ({
427
431
  request,
428
432
  dispatcher,
429
- initialData,
433
+ initialResponse,
430
434
  deepCompare,
431
435
  dependencyTracking,
432
- defaultCacheEmitting = true,
433
436
  disabled,
434
437
  revalidate
435
438
  }) => {
436
- const { client, cacheKey, queueKey, cacheTime, responseMapper } = request;
437
- const { cache, requestManager } = client;
439
+ const { client, cacheKey, queryKey, staleTime, unstable_responseMapper } = request;
440
+ const { cache } = client;
438
441
  const forceUpdate = useForceUpdate();
439
- const state = useRef2(
440
- getInitialState({ initialResponse: initialData, dispatcher, request, disabled })
441
- );
442
+ const state = useRef2(getInitialState({ initialResponse, dispatcher, request, disabled }));
442
443
  const renderKeys = useRef2([]);
443
444
  const isProcessingData = useRef2("");
444
445
  const getStaleStatus = () => {
445
446
  const cacheData = cache.get(cacheKey);
446
- return !cacheData || isStaleCacheData(cacheTime, cacheData == null ? void 0 : cacheData.timestamp);
447
+ return !cacheData || isStaleCacheData(staleTime, cacheData == null ? void 0 : cacheData.responseTimestamp);
447
448
  };
448
449
  const renderKeyTrigger = (keys) => {
449
450
  const shouldRerender = renderKeys.current.some((renderKey) => keys.includes(renderKey));
@@ -457,25 +458,20 @@ var useTrackedState = ({
457
458
  };
458
459
  useDidUpdate(
459
460
  () => {
460
- state.current.loading = dispatcher.hasRunningRequests(queueKey);
461
461
  const cacheData = cache.get(cacheKey);
462
- const cacheState = getValidCacheData(request, initialData, cacheData);
462
+ const cacheState = getValidCacheData(request, initialResponse, cacheData);
463
463
  state.current.loading = getIsInitiallyLoading({
464
- queryKey: request.queueKey,
464
+ queryKey: request.queryKey,
465
465
  dispatcher,
466
466
  disabled,
467
467
  revalidate,
468
468
  hasState: !!cacheState
469
469
  });
470
- const hasInitialState = isEqual(initialData == null ? void 0 : initialData.data, state.current.data);
471
- const hasState = !!(state.current.data || state.current.error) && !hasInitialState;
472
- const shouldLoadInitialCache = !hasState && !!state.current.data;
473
- const shouldRemovePreviousData = hasState && !state.current.data;
474
- if (cacheState || shouldLoadInitialCache || shouldRemovePreviousData) {
470
+ if (cacheState) {
475
471
  setCacheData(cacheState);
476
472
  }
477
473
  },
478
- [cacheKey, queueKey],
474
+ [cacheKey, queryKey],
479
475
  true
480
476
  );
481
477
  useDidUpdate(
@@ -507,8 +503,9 @@ var useTrackedState = ({
507
503
  success: cacheData.success,
508
504
  extra: cacheData.extra,
509
505
  retries: cacheData.retries,
510
- timestamp: new Date(cacheData.timestamp),
511
- loading: dispatcher.hasRunningRequests(queueKey)
506
+ responseTimestamp: new Date(cacheData.responseTimestamp),
507
+ requestTimestamp: new Date(cacheData.requestTimestamp),
508
+ loading: dispatcher.hasRunningRequests(queryKey)
512
509
  };
513
510
  const changedKeys = Object.keys(newStateValues).filter((key) => {
514
511
  const keyValue = key;
@@ -534,7 +531,7 @@ var useTrackedState = ({
534
531
  };
535
532
  const setCacheData = (cacheData) => {
536
533
  setIsDataProcessing({ processingCacheKey: cacheKey, isProcessing: true });
537
- const data = responseMapper ? responseMapper(cacheData) : cacheData;
534
+ const data = unstable_responseMapper ? unstable_responseMapper(cacheData) : cacheData;
538
535
  if (data instanceof Promise) {
539
536
  return (() => __async(void 0, null, function* () {
540
537
  const promiseData = yield data;
@@ -546,98 +543,84 @@ var useTrackedState = ({
546
543
  return handleCacheData(__spreadValues(__spreadValues({}, cacheData), data));
547
544
  };
548
545
  const actions = {
549
- setData: (data, emitToCache = defaultCacheEmitting) => {
550
- if (emitToCache) {
551
- const currentState = state.current;
552
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success: true, data }));
553
- } else {
554
- state.current.data = data;
555
- renderKeyTrigger(["data"]);
556
- }
546
+ setData: (data) => {
547
+ state.current.data = data instanceof Function ? data(state.current.data || null) : data;
548
+ renderKeyTrigger(["data"]);
557
549
  },
558
- setError: (error, emitToCache = defaultCacheEmitting) => {
559
- if (emitToCache) {
560
- const currentState = state.current;
561
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success: false, error }));
562
- } else {
563
- state.current.error = error;
564
- renderKeyTrigger(["error"]);
565
- }
550
+ setError: (error) => {
551
+ state.current.error = error instanceof Function ? error(state.current.error || null) : error;
552
+ renderKeyTrigger(["error"]);
566
553
  },
567
- setLoading: (loading, emitToHooks = true) => {
568
- if (emitToHooks) {
569
- requestManager.events.emitLoading(queueKey, "", {
570
- queueKey,
571
- requestId: "",
572
- loading,
573
- isRetry: false,
574
- isOffline: false
575
- });
576
- } else if (loading !== state.current.loading) {
577
- state.current.loading = loading;
578
- renderKeyTrigger(["loading"]);
579
- }
554
+ setLoading: (loading) => {
555
+ const value = loading instanceof Function ? loading(state.current.loading) : loading;
556
+ if (value === state.current.loading)
557
+ return;
558
+ state.current.loading = value;
559
+ renderKeyTrigger(["loading"]);
580
560
  },
581
- setStatus: (status, emitToCache = defaultCacheEmitting) => {
582
- if (emitToCache) {
583
- const currentState = state.current;
584
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { status }));
585
- } else {
586
- state.current.status = status;
587
- renderKeyTrigger(["status"]);
588
- }
561
+ setStatus: (status) => {
562
+ const value = status instanceof Function ? status(state.current.status) : status;
563
+ if (value === state.current.status)
564
+ return;
565
+ state.current.status = status instanceof Function ? status(state.current.status || null) : status;
566
+ renderKeyTrigger(["status"]);
589
567
  },
590
- setSuccess: (success, emitToCache = defaultCacheEmitting) => {
591
- if (emitToCache) {
592
- const currentState = state.current;
593
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success }));
594
- } else {
595
- state.current.success = success;
596
- renderKeyTrigger(["success"]);
597
- }
568
+ setSuccess: (success) => {
569
+ const value = success instanceof Function ? success(state.current.success || false) : success;
570
+ if (value === state.current.success)
571
+ return;
572
+ state.current.success = success instanceof Function ? success(state.current.success || false) : success;
573
+ renderKeyTrigger(["success"]);
598
574
  },
599
- setExtra: (extra, emitToCache = defaultCacheEmitting) => {
600
- if (emitToCache) {
601
- const currentState = state.current;
602
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { extra }));
603
- } else {
604
- state.current.extra = extra;
605
- renderKeyTrigger(["extra"]);
606
- }
575
+ setExtra: (extra) => {
576
+ const value = extra instanceof Function ? extra(state.current.extra) : extra;
577
+ if (value === state.current.extra)
578
+ return;
579
+ state.current.extra = extra instanceof Function ? extra(state.current.extra) : extra;
580
+ renderKeyTrigger(["extra"]);
607
581
  },
608
- setRetries: (retries, emitToCache = defaultCacheEmitting) => {
609
- if (emitToCache) {
610
- const currentState = state.current;
611
- cache.set(request, __spreadValues(__spreadValues({}, currentState), getDetailsState(state.current, { retries })));
612
- } else {
613
- state.current.retries = retries;
614
- renderKeyTrigger(["retries"]);
615
- }
582
+ setRetries: (retries) => {
583
+ const value = retries instanceof Function ? retries(state.current.retries || 0) : retries;
584
+ if (value === state.current.retries)
585
+ return;
586
+ state.current.retries = retries instanceof Function ? retries(state.current.retries || 0) : retries;
587
+ renderKeyTrigger(["retries"]);
616
588
  },
617
- setTimestamp: (timestamp, emitToCache = defaultCacheEmitting) => {
618
- if (emitToCache) {
619
- const currentState = state.current;
620
- cache.set(request, __spreadValues(__spreadValues({}, currentState), getDetailsState(state.current, { timestamp: +timestamp })));
621
- } else {
622
- state.current.timestamp = timestamp;
623
- renderKeyTrigger(["timestamp"]);
624
- }
589
+ setResponseTimestamp: (timestamp) => {
590
+ const value = timestamp instanceof Function ? timestamp(state.current.responseTimestamp) : timestamp;
591
+ if (value === state.current.responseTimestamp)
592
+ return;
593
+ const getTimestamp2 = (prev) => {
594
+ return timestamp instanceof Function ? timestamp(prev ? new Date(prev) : null) : timestamp;
595
+ };
596
+ state.current.responseTimestamp = getTimestamp2(state.current.responseTimestamp);
597
+ renderKeyTrigger(["responseTimestamp"]);
598
+ },
599
+ setRequestTimestamp: (timestamp) => {
600
+ const value = timestamp instanceof Function ? timestamp(state.current.requestTimestamp) : timestamp;
601
+ if (value === state.current.requestTimestamp)
602
+ return;
603
+ const getTimestamp2 = (prev) => {
604
+ return timestamp instanceof Function ? timestamp(prev ? new Date(prev) : null) : timestamp;
605
+ };
606
+ state.current.requestTimestamp = getTimestamp2(state.current.requestTimestamp);
607
+ renderKeyTrigger(["requestTimestamp"]);
625
608
  }
626
609
  };
627
610
  return [state.current, actions, { setRenderKey, setCacheData, getStaleStatus, getIsDataProcessing }];
628
611
  };
629
612
 
630
613
  // src/helpers/use-socket-state/use-socket-state.hooks.ts
631
- import { useRef as useRef3 } from "react";
632
614
  import { useDidMount, useDidUpdate as useDidUpdate2, useForceUpdate as useForceUpdate2 } from "@better-hooks/lifecycle";
615
+ import { useRef as useRef3 } from "react";
633
616
  var useSocketState = (socket, { dependencyTracking }) => {
634
617
  const forceUpdate = useForceUpdate2();
635
- const onOpenCallback = useRef3(null);
636
- const onCloseCallback = useRef3(null);
618
+ const onDisconnectCallback = useRef3(null);
637
619
  const onErrorCallback = useRef3(null);
620
+ const onConnectedCallback = useRef3(null);
638
621
  const onConnectingCallback = useRef3(null);
639
622
  const onReconnectingCallback = useRef3(null);
640
- const onReconnectingStopCallback = useRef3(null);
623
+ const onReconnectingFailedCallback = useRef3(null);
641
624
  const state = useRef3(initialSocketState);
642
625
  const renderKeys = useRef3([]);
643
626
  const renderKeyTrigger = (keys) => {
@@ -652,6 +635,8 @@ var useSocketState = (socket, { dependencyTracking }) => {
652
635
  };
653
636
  useDidUpdate2(
654
637
  () => {
638
+ state.current.connected = socket.adapter.connected;
639
+ state.current.connecting = socket.adapter.connecting;
655
640
  const handleDependencyTracking = () => {
656
641
  if (!dependencyTracking) {
657
642
  Object.keys(state.current).forEach((key) => setRenderKey(key));
@@ -667,6 +652,10 @@ var useSocketState = (socket, { dependencyTracking }) => {
667
652
  state.current.data = data;
668
653
  renderKeyTrigger(["data"]);
669
654
  },
655
+ setExtra: (extra) => {
656
+ state.current.extra = extra;
657
+ renderKeyTrigger(["extra"]);
658
+ },
670
659
  setConnected: (connected) => {
671
660
  state.current.connected = connected;
672
661
  renderKeyTrigger(["data"]);
@@ -681,11 +670,11 @@ var useSocketState = (socket, { dependencyTracking }) => {
681
670
  }
682
671
  };
683
672
  const callbacks = {
684
- onOpen: (callback) => {
685
- onOpenCallback.current = callback;
673
+ onConnected: (callback) => {
674
+ onConnectedCallback.current = callback;
686
675
  },
687
- onClose: (callback) => {
688
- onCloseCallback.current = callback;
676
+ onDisconnected: (callback) => {
677
+ onDisconnectCallback.current = callback;
689
678
  },
690
679
  onError: (callback) => {
691
680
  onErrorCallback.current = callback;
@@ -696,8 +685,8 @@ var useSocketState = (socket, { dependencyTracking }) => {
696
685
  onReconnecting: (callback) => {
697
686
  onReconnectingCallback.current = callback;
698
687
  },
699
- onReconnectingStop: (callback) => {
700
- onReconnectingStopCallback.current = callback;
688
+ onReconnectingFailed: (callback) => {
689
+ onReconnectingFailedCallback.current = callback;
701
690
  }
702
691
  };
703
692
  useDidMount(() => {
@@ -705,28 +694,28 @@ var useSocketState = (socket, { dependencyTracking }) => {
705
694
  var _a;
706
695
  (_a = onErrorCallback.current) == null ? void 0 : _a.call(onErrorCallback, event);
707
696
  });
708
- const umountOnConnecting = socket.events.onConnecting(() => {
697
+ const umountOnConnecting = socket.events.onConnecting(({ connecting }) => {
709
698
  var _a;
710
- actions.setConnecting(true);
699
+ actions.setConnecting(connecting);
711
700
  (_a = onConnectingCallback.current) == null ? void 0 : _a.call(onConnectingCallback);
712
701
  });
713
- const umountOnOpen = socket.events.onOpen(() => {
702
+ const umountOnOpen = socket.events.onConnected(() => {
714
703
  var _a;
715
704
  actions.setConnected(true);
716
- (_a = onOpenCallback.current) == null ? void 0 : _a.call(onOpenCallback);
705
+ (_a = onConnectedCallback.current) == null ? void 0 : _a.call(onConnectedCallback);
717
706
  });
718
- const umountOnClose = socket.events.onClose(() => {
707
+ const umountOnClose = socket.events.onDisconnected(() => {
719
708
  var _a;
720
709
  actions.setConnected(false);
721
- (_a = onCloseCallback.current) == null ? void 0 : _a.call(onCloseCallback);
710
+ (_a = onDisconnectCallback.current) == null ? void 0 : _a.call(onDisconnectCallback);
722
711
  });
723
- const umountOnReconnecting = socket.events.onReconnecting((attempts) => {
712
+ const umountOnReconnecting = socket.events.onReconnecting(({ attempts }) => {
724
713
  var _a;
725
- (_a = onReconnectingCallback.current) == null ? void 0 : _a.call(onReconnectingCallback, attempts);
714
+ (_a = onReconnectingCallback.current) == null ? void 0 : _a.call(onReconnectingCallback, { attempts });
726
715
  });
727
- const umountOnReconnectingStop = socket.events.onReconnectingStop((attempts) => {
716
+ const umountOnReconnectingFailed = socket.events.onReconnectingFailed(({ attempts }) => {
728
717
  var _a;
729
- (_a = onReconnectingStopCallback.current) == null ? void 0 : _a.call(onReconnectingStopCallback, attempts);
718
+ (_a = onReconnectingFailedCallback.current) == null ? void 0 : _a.call(onReconnectingFailedCallback, { attempts });
730
719
  });
731
720
  return () => {
732
721
  umountOnError();
@@ -734,7 +723,7 @@ var useSocketState = (socket, { dependencyTracking }) => {
734
723
  umountOnOpen();
735
724
  umountOnClose();
736
725
  umountOnReconnecting();
737
- umountOnReconnectingStop();
726
+ umountOnReconnectingFailed();
738
727
  };
739
728
  });
740
729
  return [state.current, actions, callbacks, { setRenderKey }];
@@ -743,64 +732,68 @@ var useSocketState = (socket, { dependencyTracking }) => {
743
732
  // src/helpers/use-socket-state/use-socket-state.constants.ts
744
733
  var initialSocketState = {
745
734
  data: null,
735
+ extra: null,
746
736
  connected: false,
747
737
  connecting: false,
748
738
  timestamp: null
749
739
  };
750
740
 
751
- // src/config-provider/config-provider.tsx
741
+ // src/provider/provider.tsx
752
742
  import React, { useContext, useMemo, useState } from "react";
753
743
  import { jsx } from "react/jsx-runtime";
754
- var ConfigContext = React.createContext([{}, () => null]);
755
- var ConfigProvider = ({ children, config }) => {
744
+ var ConfigContext = React.createContext({
745
+ config: {},
746
+ setConfig: () => null
747
+ });
748
+ var Provider = ({ children, config }) => {
756
749
  const [currentConfig, setConfig] = useState(config || {});
757
750
  const value = useMemo(() => {
758
- const contextValue = [currentConfig, setConfig];
751
+ const contextValue = { config: currentConfig, setConfig };
759
752
  return contextValue;
760
753
  }, [currentConfig]);
761
754
  return /* @__PURE__ */ jsx(ConfigContext.Provider, { value, children });
762
755
  };
763
- var useConfigProvider = () => {
756
+ var useProvider = () => {
764
757
  const config = useContext(ConfigContext);
765
758
  return config;
766
759
  };
767
760
 
768
761
  // src/hooks/use-fetch/use-fetch.hooks.ts
769
- var useFetch = (request, options = useFetchDefaultOptions) => {
770
- const [globalConfig] = useConfigProvider();
762
+ var useFetch = (request, options) => {
763
+ const { config: globalConfig } = useProvider();
771
764
  const {
772
- dependencies = useFetchDefaultOptions.dependencies,
773
- disabled = useFetchDefaultOptions.disabled,
774
- dependencyTracking = useFetchDefaultOptions.dependencyTracking,
775
- revalidate = useFetchDefaultOptions.revalidate,
776
- initialData = useFetchDefaultOptions.initialData,
777
- refresh = useFetchDefaultOptions.refresh,
778
- refreshTime = useFetchDefaultOptions.refreshTime,
779
- refetchBlurred = useFetchDefaultOptions.refetchBlurred,
780
- refetchOnBlur = useFetchDefaultOptions.refetchOnBlur,
781
- refetchOnFocus = useFetchDefaultOptions.refetchOnFocus,
782
- refetchOnReconnect = useFetchDefaultOptions.refetchOnReconnect,
783
- bounce = useFetchDefaultOptions.bounce,
784
- bounceType = useFetchDefaultOptions.bounceType,
785
- bounceTime = useFetchDefaultOptions.bounceTime,
786
- bounceTimeout = useFetchDefaultOptions.bounceTime,
787
- deepCompare = useFetchDefaultOptions.deepCompare
765
+ dependencies,
766
+ disabled,
767
+ dependencyTracking,
768
+ revalidate,
769
+ initialResponse,
770
+ refresh,
771
+ refreshTime,
772
+ refetchBlurred,
773
+ refetchOnBlur,
774
+ refetchOnFocus,
775
+ refetchOnReconnect,
776
+ bounce,
777
+ bounceType,
778
+ bounceTime,
779
+ bounceTimeout,
780
+ deepCompare
788
781
  } = __spreadValues(__spreadValues(__spreadValues({}, useFetchDefaultOptions), globalConfig.useFetchConfig), options);
789
782
  const updateKey = JSON.stringify(request.toJSON());
790
783
  const requestDebounce = useDebounce({ delay: bounceTime });
791
784
  const requestThrottle = useThrottle({ interval: bounceTime, timeout: bounceTimeout });
792
785
  const refreshDebounce = useDebounce({ delay: refreshTime });
793
- const { cacheKey, queueKey, client } = request;
786
+ const { cacheKey, queryKey, client } = request;
794
787
  const { cache, fetchDispatcher: dispatcher, appManager, loggerManager } = client;
795
788
  const ignoreReact18DoubleRender = useRef4(true);
796
- const logger = useRef4(loggerManager.init("useFetch")).current;
789
+ const logger = useRef4(loggerManager.initialize(client, "useFetch")).current;
797
790
  const bounceData = bounceType === "throttle" ? requestThrottle : requestDebounce;
798
791
  const bounceFunction = bounceType === "throttle" ? requestThrottle.throttle : requestDebounce.debounce;
799
792
  const [state, actions, { setRenderKey, setCacheData, getStaleStatus, getIsDataProcessing }] = useTrackedState({
800
793
  logger,
801
794
  request,
802
795
  dispatcher,
803
- initialData,
796
+ initialResponse,
804
797
  deepCompare,
805
798
  dependencyTracking,
806
799
  disabled,
@@ -817,10 +810,10 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
817
810
  const { addCacheDataListener, addLifecycleListeners, clearCacheDataListener } = listeners;
818
811
  const handleFetch = () => {
819
812
  if (!disabled) {
820
- logger.debug(`Fetching data`);
813
+ logger.debug({ title: `Fetching data`, type: "system", extra: { request } });
821
814
  dispatcher.add(request);
822
815
  } else {
823
- logger.debug(`Cannot add to fetch queue`, { disabled });
816
+ logger.debug({ title: `Cannot add to fetch queue`, type: "system", extra: { disabled } });
824
817
  }
825
818
  };
826
819
  function handleRefresh() {
@@ -830,37 +823,24 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
830
823
  }
831
824
  refreshDebounce.debounce(() => {
832
825
  const isBlurred = !appManager.isFocused;
833
- const isFetching = dispatcher.hasRunningRequests(request.queueKey);
834
- const isQueued = dispatcher.getIsActiveQueue(request.queueKey);
826
+ const isFetching = dispatcher.hasRunningRequests(request.queryKey);
827
+ const isQueued = dispatcher.getIsActiveQueue(request.queryKey);
835
828
  const isActive = isFetching || isQueued;
836
829
  const canRefreshBlurred = isBlurred && refetchBlurred && !isActive;
837
830
  const canRefreshFocused = !isBlurred && !isActive;
838
831
  if (canRefreshBlurred || canRefreshFocused) {
839
832
  handleFetch();
840
- logger.debug(`Performing refresh request`);
833
+ logger.debug({ title: `Performing refresh request`, type: "system", extra: { request } });
841
834
  }
842
835
  handleRefresh();
843
836
  });
844
837
  }
845
- const handleInvalidation = (invalidateKey) => {
846
- if (invalidateKey && invalidateKey instanceof Request) {
847
- cache.invalidate(getRequestKey(invalidateKey));
848
- } else if (invalidateKey && !(invalidateKey instanceof Request)) {
849
- cache.invalidate(invalidateKey);
850
- }
851
- };
852
- const refetch = (invalidateKey) => {
853
- if (invalidateKey && Array.isArray(invalidateKey)) {
854
- invalidateKey.forEach(handleInvalidation);
855
- } else if (invalidateKey && !Array.isArray(invalidateKey)) {
856
- handleInvalidation(invalidateKey);
857
- } else {
858
- handleFetch();
859
- handleRefresh();
860
- }
838
+ const refetch = () => {
839
+ handleFetch();
840
+ handleRefresh();
861
841
  };
862
842
  const getIsFetchingIdentity = () => {
863
- return dispatcher.getRunningRequests(queueKey).some((running) => running.request.cacheKey === cacheKey);
843
+ return dispatcher.getRunningRequests(queryKey).some((running) => running.request.cacheKey === cacheKey);
864
844
  };
865
845
  const initialFetchData = () => {
866
846
  const hasStaleData = getStaleStatus();
@@ -874,7 +854,7 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
874
854
  const shouldUpdate = !revalidate ? hasStaleData : true;
875
855
  if (!ignoreReact18DoubleRender.current && shouldUpdate) {
876
856
  if (bounce) {
877
- logger.debug(`Bounce request with ${bounceType}`, { queueKey, request });
857
+ logger.debug({ title: `Bounce request with ${bounceType}`, type: "system", extra: { queryKey, request } });
878
858
  bounceFunction(() => handleFetch());
879
859
  } else {
880
860
  handleFetch();
@@ -904,13 +884,15 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
904
884
  handleRefresh();
905
885
  }
906
886
  });
907
- const invalidateUnmount = cache.events.onInvalidate(cacheKey, handleFetch);
887
+ const invalidateUnmount = cache.events.onInvalidateByKey(cacheKey, handleFetch);
888
+ const deletionUnmount = cache.events.onDeleteByKey(cacheKey, handleFetch);
908
889
  const unmount = () => {
909
890
  clearCacheDataListener();
910
891
  focusUnmount();
911
892
  blurUnmount();
912
893
  onlineUnmount();
913
894
  invalidateUnmount();
895
+ deletionUnmount();
914
896
  };
915
897
  return unmount;
916
898
  };
@@ -950,9 +932,13 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
950
932
  setRenderKey("retries");
951
933
  return state.retries;
952
934
  },
953
- get timestamp() {
954
- setRenderKey("timestamp");
955
- return state.timestamp;
935
+ get responseTimestamp() {
936
+ setRenderKey("responseTimestamp");
937
+ return state.responseTimestamp;
938
+ },
939
+ get requestTimestamp() {
940
+ setRenderKey("requestTimestamp");
941
+ return state.requestTimestamp;
956
942
  },
957
943
  bounce: getBounceData(bounceData)
958
944
  }, actions), callbacks), {
@@ -970,15 +956,15 @@ var getRefreshTime = (refreshTime, dataTimestamp) => {
970
956
  };
971
957
 
972
958
  // src/hooks/use-fetch/use-fetch.constants.ts
973
- import { DateInterval } from "@hyper-fetch/core";
959
+ import { Time } from "@hyper-fetch/core";
974
960
  var useFetchDefaultOptions = {
975
961
  dependencies: [],
976
962
  disabled: false,
977
963
  dependencyTracking: true,
978
964
  revalidate: true,
979
- initialData: null,
965
+ initialResponse: null,
980
966
  refresh: false,
981
- refreshTime: DateInterval.hour,
967
+ refreshTime: Time.HOUR,
982
968
  refetchBlurred: true,
983
969
  refetchOnBlur: false,
984
970
  refetchOnFocus: false,
@@ -986,28 +972,28 @@ var useFetchDefaultOptions = {
986
972
  bounce: false,
987
973
  bounceType: "debounce",
988
974
  bounceTime: 400,
975
+ bounceTimeout: 400,
989
976
  deepCompare: true
990
977
  };
991
978
 
992
979
  // src/hooks/use-submit/use-submit.hooks.ts
993
- import { useMemo as useMemo2, useRef as useRef5 } from "react";
994
980
  import {
995
- Request as Request2,
996
- getRequestKey as getRequestKey2,
997
981
  sendRequest
998
982
  } from "@hyper-fetch/core";
999
983
  import { useDidMount as useDidMount3 } from "@better-hooks/lifecycle";
1000
984
  import { useDebounce as useDebounce2, useThrottle as useThrottle2 } from "@better-hooks/performance";
1001
- var useSubmit = (request, options = useSubmitDefaultOptions) => {
1002
- const [globalConfig] = useConfigProvider();
985
+ import { useMemo as useMemo2, useRef as useRef5 } from "react";
986
+ var useSubmit = (request, options) => {
987
+ const { config: globalConfig } = useProvider();
1003
988
  const mergedOptions = useMemo2(
1004
989
  () => __spreadValues(__spreadValues(__spreadValues({}, useSubmitDefaultOptions), globalConfig.useSubmitConfig), options),
1005
- [globalConfig.useSubmitConfig, JSON.stringify(options), options.deepCompare]
990
+ // eslint-disable-next-line react-hooks/exhaustive-deps
991
+ [globalConfig.useSubmitConfig, JSON.stringify(options), options == null ? void 0 : options.deepCompare]
1006
992
  );
1007
- const { disabled, dependencyTracking, initialData, bounce, bounceType, bounceTime, deepCompare } = mergedOptions;
993
+ const { disabled, dependencyTracking, initialResponse, bounce, bounceType, bounceTime, deepCompare } = mergedOptions;
1008
994
  const { client } = request;
1009
995
  const { cache, submitDispatcher: dispatcher, loggerManager } = client;
1010
- const logger = useRef5(loggerManager.init("useSubmit")).current;
996
+ const logger = useRef5(loggerManager.initialize(client, "useSubmit")).current;
1011
997
  const requestDebounce = useDebounce2({ delay: bounceTime });
1012
998
  const requestThrottle = useThrottle2({
1013
999
  interval: bounceTime,
@@ -1020,7 +1006,7 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1020
1006
  logger,
1021
1007
  request,
1022
1008
  dispatcher,
1023
- initialData,
1009
+ initialResponse,
1024
1010
  deepCompare,
1025
1011
  dependencyTracking
1026
1012
  });
@@ -1036,29 +1022,30 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1036
1022
  const handleSubmit = (submitOptions) => {
1037
1023
  const requestClone = request.clone(submitOptions);
1038
1024
  if (disabled) {
1039
- logger.warning(`Cannot submit request`, { disabled, submitOptions });
1025
+ logger.warning({ title: `Cannot submit request`, type: "system", extra: { disabled, submitOptions } });
1040
1026
  return Promise.resolve({
1041
1027
  data: null,
1042
1028
  error: new Error("Cannot submit request. Option 'disabled' is enabled"),
1043
1029
  status: null,
1044
- extra: request.client.defaultExtra
1030
+ extra: request.client.adapter.defaultExtra
1045
1031
  });
1046
1032
  }
1047
1033
  const triggerRequest = () => {
1048
1034
  addCacheDataListener(requestClone);
1049
- return sendRequest(requestClone, __spreadProps(__spreadValues({
1035
+ const configuration = __spreadProps(__spreadValues({
1050
1036
  dispatcherType: "submit"
1051
1037
  }, submitOptions), {
1052
- onSettle: (requestId, cmd) => {
1038
+ onBeforeSent: (data) => {
1053
1039
  var _a;
1054
- addLifecycleListeners(requestClone, requestId);
1055
- (_a = submitOptions == null ? void 0 : submitOptions.onSettle) == null ? void 0 : _a.call(submitOptions, requestId, cmd);
1040
+ addLifecycleListeners(requestClone, data.requestId);
1041
+ (_a = submitOptions == null ? void 0 : submitOptions.onBeforeSent) == null ? void 0 : _a.call(submitOptions, data);
1056
1042
  }
1057
- }));
1043
+ });
1044
+ return sendRequest(requestClone, configuration);
1058
1045
  };
1059
1046
  return new Promise((resolve) => {
1060
1047
  const performSubmit = () => __async(void 0, null, function* () {
1061
- logger.debug(`Submitting request`, { disabled, submitOptions });
1048
+ logger.debug({ title: `Submitting request`, type: "system", extra: { disabled, submitOptions } });
1062
1049
  if (bounce) {
1063
1050
  const bouncedResolve = bounceResolver.current;
1064
1051
  bounceResolver.current = (value) => {
@@ -1079,21 +1066,8 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1079
1066
  performSubmit();
1080
1067
  });
1081
1068
  };
1082
- const handleInvalidation = (invalidateKey) => {
1083
- if (invalidateKey && invalidateKey instanceof Request2) {
1084
- cache.invalidate(getRequestKey2(invalidateKey));
1085
- } else if (invalidateKey && !(invalidateKey instanceof Request2)) {
1086
- cache.invalidate(invalidateKey);
1087
- }
1088
- };
1089
- const refetch = (invalidateKey) => {
1090
- if (!invalidateKey)
1091
- return;
1092
- if (invalidateKey && Array.isArray(invalidateKey)) {
1093
- invalidateKey.forEach(handleInvalidation);
1094
- } else if (invalidateKey && !Array.isArray(invalidateKey)) {
1095
- handleInvalidation(invalidateKey);
1096
- }
1069
+ const refetch = () => {
1070
+ cache.invalidate(request);
1097
1071
  };
1098
1072
  const handlers = {
1099
1073
  onSubmitSuccess: callbacks.onSuccess,
@@ -1139,9 +1113,13 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1139
1113
  setRenderKey("retries");
1140
1114
  return state.retries;
1141
1115
  },
1142
- get timestamp() {
1143
- setRenderKey("timestamp");
1144
- return state.timestamp;
1116
+ get responseTimestamp() {
1117
+ setRenderKey("responseTimestamp");
1118
+ return state.responseTimestamp;
1119
+ },
1120
+ get requestTimestamp() {
1121
+ setRenderKey("requestTimestamp");
1122
+ return state.requestTimestamp;
1145
1123
  },
1146
1124
  abort: callbacks.abort
1147
1125
  }, actions), handlers), {
@@ -1154,7 +1132,7 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1154
1132
  var useSubmitDefaultOptions = {
1155
1133
  disabled: false,
1156
1134
  dependencyTracking: true,
1157
- initialData: null,
1135
+ initialResponse: null,
1158
1136
  bounce: false,
1159
1137
  bounceType: "debounce",
1160
1138
  bounceTime: 400,
@@ -1162,94 +1140,167 @@ var useSubmitDefaultOptions = {
1162
1140
  };
1163
1141
 
1164
1142
  // src/hooks/use-queue/use-queue.hooks.ts
1165
- import { useState as useState2, useRef as useRef6 } from "react";
1166
1143
  import { getRequestDispatcher } from "@hyper-fetch/core";
1167
- import { useDidMount as useDidMount4, useDidUpdate as useDidUpdate4 } from "@better-hooks/lifecycle";
1168
- var useQueue = (request, options = useQueueDefaultOptions) => {
1169
- const [globalConfig] = useConfigProvider();
1170
- const { queueType = "auto" } = __spreadValues(__spreadValues(__spreadValues({}, useQueueDefaultOptions), globalConfig.useQueueConfig), options);
1171
- const { abortKey, queueKey, client } = request;
1144
+ import { useState as useState2, useEffect, useCallback } from "react";
1145
+ var canUpdate = (item) => {
1146
+ if (item.success || item.failed) {
1147
+ return false;
1148
+ }
1149
+ return true;
1150
+ };
1151
+ var useQueue = (request, options) => {
1152
+ const { config: globalConfig } = useProvider();
1153
+ const { dispatcherType, keepFinishedRequests } = __spreadValues(__spreadValues(__spreadValues({}, useQueueDefaultOptions), globalConfig.useQueueConfig), options);
1154
+ const { abortKey, queryKey, client } = request;
1172
1155
  const { requestManager } = client;
1173
- const [dispatcher] = getRequestDispatcher(request, queueType);
1174
- const unmountCallbacks = useRef6(null);
1156
+ const [dispatcher] = getRequestDispatcher(request, dispatcherType);
1175
1157
  const [stopped, setStopped] = useState2(false);
1176
1158
  const [requests, setRequests] = useState2([]);
1177
- const createRequestsArray = (queueElements) => {
1178
- return queueElements.map((req) => __spreadProps(__spreadValues({}, req), {
1179
- stopRequest: () => dispatcher.stopRequest(queueKey, req.requestId),
1180
- startRequest: () => dispatcher.startRequest(queueKey, req.requestId),
1181
- deleteRequest: () => dispatcher.delete(queueKey, req.requestId, abortKey)
1182
- }));
1183
- };
1184
- const mergePayloadType = (requestId, data) => {
1185
- setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadValues(__spreadValues({}, el), data) : el));
1186
- };
1159
+ const createRequestsArray = useCallback(
1160
+ (queueElements, prevRequests) => {
1161
+ const newRequests = queueElements.filter((el) => !(prevRequests == null ? void 0 : prevRequests.some((prevEl) => prevEl.requestId === el.requestId))).map((req) => __spreadProps(__spreadValues({
1162
+ failed: false,
1163
+ canceled: false,
1164
+ removed: false,
1165
+ success: false
1166
+ }, req), {
1167
+ downloading: {
1168
+ progress: 0,
1169
+ timeLeft: 0,
1170
+ sizeLeft: 0,
1171
+ total: 0,
1172
+ loaded: 0,
1173
+ startTimestamp: 0
1174
+ },
1175
+ uploading: {
1176
+ progress: 0,
1177
+ timeLeft: 0,
1178
+ sizeLeft: 0,
1179
+ total: 0,
1180
+ loaded: 0,
1181
+ startTimestamp: 0
1182
+ },
1183
+ stopRequest: () => dispatcher.stopRequest(queryKey, req.requestId),
1184
+ startRequest: () => dispatcher.startRequest(queryKey, req.requestId),
1185
+ deleteRequest: () => dispatcher.delete(queryKey, req.requestId, abortKey)
1186
+ }));
1187
+ if (keepFinishedRequests && prevRequests) {
1188
+ return [...prevRequests, ...newRequests];
1189
+ }
1190
+ return newRequests;
1191
+ },
1192
+ [abortKey, dispatcher, queryKey, keepFinishedRequests]
1193
+ );
1194
+ const mergePayloadType = useCallback((requestId, data) => {
1195
+ setRequests(
1196
+ (prev) => prev.map((el) => {
1197
+ if (el.requestId === requestId && canUpdate(el)) {
1198
+ return __spreadValues(__spreadValues({}, el), data);
1199
+ }
1200
+ return el;
1201
+ })
1202
+ );
1203
+ }, []);
1187
1204
  const getInitialState2 = () => {
1188
- const requestQueue = dispatcher.getQueue(queueKey);
1205
+ const requestQueue = dispatcher.getQueue(queryKey);
1189
1206
  setStopped(requestQueue.stopped);
1190
1207
  setRequests(createRequestsArray(requestQueue.requests));
1191
1208
  };
1192
- const updateQueueState = (values) => {
1193
- setStopped(values.stopped);
1194
- setRequests(createRequestsArray(values.requests));
1195
- };
1209
+ const updateQueueState = useCallback(
1210
+ (values) => {
1211
+ setStopped(values.stopped);
1212
+ setRequests((prev) => createRequestsArray(values.requests, prev));
1213
+ },
1214
+ [createRequestsArray]
1215
+ );
1196
1216
  const mountEvents = () => {
1197
- var _a;
1198
- const unmountChange = dispatcher.events.onQueueChange(queueKey, updateQueueState);
1199
- const unmountStatus = dispatcher.events.onQueueStatus(queueKey, updateQueueState);
1200
- const unmountDownload = requestManager.events.onDownloadProgress(queueKey, (progress, { requestId }) => {
1201
- mergePayloadType(requestId, { downloading: progress });
1217
+ const unmountChange = dispatcher.events.onQueueChangeByKey(queryKey, updateQueueState);
1218
+ const unmountStatus = dispatcher.events.onQueueStatusChangeByKey(queryKey, updateQueueState);
1219
+ const unmountFailed = requestManager.events.onResponse(({ requestId, response }) => {
1220
+ if (!response.success) {
1221
+ setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadProps(__spreadValues({}, el), { failed: true }) : el));
1222
+ } else {
1223
+ setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadProps(__spreadValues({}, el), { success: true }) : el));
1224
+ }
1202
1225
  });
1203
- const unmountUpload = requestManager.events.onUploadProgress(queueKey, (progress, { requestId }) => {
1204
- mergePayloadType(requestId, { uploading: progress });
1226
+ const unmountCanceled = requestManager.events.onAbort(({ requestId }) => {
1227
+ setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadProps(__spreadValues({}, el), { canceled: true }) : el));
1228
+ });
1229
+ const unmountRemoved = requestManager.events.onRemove(({ requestId }) => {
1230
+ setRequests(
1231
+ (prev) => prev.map((el) => el.requestId === requestId && canUpdate(el) ? __spreadProps(__spreadValues({}, el), { removed: true }) : el)
1232
+ );
1205
1233
  });
1234
+ const unmountDownload = requestManager.events.onDownloadProgress(
1235
+ ({ progress, timeLeft, sizeLeft, total, loaded, startTimestamp, requestId }) => {
1236
+ mergePayloadType(requestId, { downloading: { progress, timeLeft, sizeLeft, total, loaded, startTimestamp } });
1237
+ }
1238
+ );
1239
+ const unmountUpload = requestManager.events.onUploadProgress(
1240
+ ({ progress, timeLeft, sizeLeft, total, loaded, startTimestamp, requestId }) => {
1241
+ mergePayloadType(requestId, { uploading: { progress, timeLeft, sizeLeft, total, loaded, startTimestamp } });
1242
+ }
1243
+ );
1206
1244
  const unmount = () => {
1207
1245
  unmountStatus();
1208
1246
  unmountChange();
1209
1247
  unmountDownload();
1210
1248
  unmountUpload();
1249
+ unmountFailed();
1250
+ unmountCanceled();
1251
+ unmountRemoved();
1211
1252
  };
1212
- (_a = unmountCallbacks.current) == null ? void 0 : _a.call(unmountCallbacks);
1213
- unmountCallbacks.current = unmount;
1214
1253
  return unmount;
1215
1254
  };
1216
- useDidMount4(getInitialState2);
1217
- useDidUpdate4(mountEvents, [stopped, requests, setRequests, setStopped], true);
1255
+ useEffect(getInitialState2, [createRequestsArray, dispatcher, queryKey]);
1256
+ useEffect(mountEvents, [
1257
+ stopped,
1258
+ requests,
1259
+ setRequests,
1260
+ setStopped,
1261
+ queryKey,
1262
+ dispatcher.events,
1263
+ requestManager.events,
1264
+ updateQueueState,
1265
+ mergePayloadType
1266
+ ]);
1218
1267
  return {
1219
1268
  stopped,
1220
1269
  requests,
1221
- stop: () => dispatcher.stop(queueKey),
1222
- pause: () => dispatcher.pause(queueKey),
1223
- start: () => dispatcher.start(queueKey)
1270
+ dispatcher,
1271
+ stop: () => dispatcher.stop(queryKey),
1272
+ pause: () => dispatcher.pause(queryKey),
1273
+ start: () => dispatcher.start(queryKey)
1224
1274
  };
1225
1275
  };
1226
1276
 
1227
1277
  // src/hooks/use-queue/use-queue.constants.ts
1228
1278
  var useQueueDefaultOptions = {
1229
- queueType: "auto"
1279
+ dispatcherType: "auto",
1280
+ keepFinishedRequests: false
1230
1281
  };
1231
1282
 
1232
1283
  // src/hooks/use-cache/use-cache.hooks.ts
1233
- import { useRef as useRef7 } from "react";
1234
- import { useDidUpdate as useDidUpdate5 } from "@better-hooks/lifecycle";
1235
- import { getRequestDispatcher as getRequestDispatcher2, Request as Request3, getRequestKey as getRequestKey3 } from "@hyper-fetch/core";
1236
- var useCache = (request, options = useCacheDefaultOptions) => {
1284
+ import { useDidUpdate as useDidUpdate4 } from "@better-hooks/lifecycle";
1285
+ import { getRequestDispatcher as getRequestDispatcher2 } from "@hyper-fetch/core";
1286
+ import { useRef as useRef6 } from "react";
1287
+ var useCache = (request, options) => {
1237
1288
  const { cacheKey, client } = request;
1238
1289
  const { cache, loggerManager } = client;
1239
- const logger = useRef7(loggerManager.init("useCache")).current;
1290
+ const logger = useRef6(loggerManager.initialize(client, "useCache")).current;
1240
1291
  const [dispatcher] = getRequestDispatcher2(request);
1241
1292
  const updateKey = JSON.stringify(request.toJSON());
1242
- const [globalConfig] = useConfigProvider();
1243
- const { dependencyTracking, initialData, deepCompare } = __spreadValues(__spreadValues(__spreadValues({}, useCacheDefaultOptions), globalConfig.useCacheConfig), options);
1293
+ const { config: globalConfig } = useProvider();
1294
+ const { dependencyTracking, initialResponse, deepCompare } = __spreadValues(__spreadValues(__spreadValues({}, useCacheDefaultOptions), globalConfig.useCacheConfig), options);
1244
1295
  const [state, actions, { setRenderKey, setCacheData, getIsDataProcessing }] = useTrackedState({
1245
1296
  logger,
1246
1297
  request,
1247
1298
  dispatcher,
1248
- initialData,
1299
+ initialResponse,
1249
1300
  deepCompare,
1250
1301
  dependencyTracking
1251
1302
  });
1252
- const [callbacks, listeners] = useRequestEvents({
1303
+ const [, listeners] = useRequestEvents({
1253
1304
  logger,
1254
1305
  actions,
1255
1306
  request,
@@ -1259,18 +1310,22 @@ var useCache = (request, options = useCacheDefaultOptions) => {
1259
1310
  });
1260
1311
  const { addCacheDataListener, addLifecycleListeners } = listeners;
1261
1312
  const handleMountEvents = () => {
1262
- addCacheDataListener(request);
1263
- addLifecycleListeners(request);
1313
+ const unmountDataListener = addCacheDataListener(request);
1314
+ const unmountLifecycleListener = addLifecycleListeners(request);
1315
+ return () => {
1316
+ unmountDataListener();
1317
+ unmountLifecycleListener();
1318
+ };
1264
1319
  };
1265
- useDidUpdate5(handleMountEvents, [updateKey], true);
1266
- const refetch = (invalidateKey) => {
1267
- if (invalidateKey instanceof Request3) {
1268
- cache.invalidate(getRequestKey3(invalidateKey, true));
1269
- } else if (invalidateKey) {
1270
- cache.invalidate(invalidateKey);
1271
- } else {
1272
- cache.invalidate(cacheKey);
1273
- }
1320
+ useDidUpdate4(
1321
+ () => {
1322
+ return handleMountEvents();
1323
+ },
1324
+ [updateKey],
1325
+ true
1326
+ );
1327
+ const invalidate = (cacheKeys) => {
1328
+ cache.invalidate(cacheKeys != null ? cacheKeys : cacheKey);
1274
1329
  };
1275
1330
  return __spreadProps(__spreadValues({
1276
1331
  get data() {
@@ -1301,47 +1356,47 @@ var useCache = (request, options = useCacheDefaultOptions) => {
1301
1356
  setRenderKey("retries");
1302
1357
  return state.retries;
1303
1358
  },
1304
- get timestamp() {
1305
- setRenderKey("timestamp");
1306
- return state.timestamp;
1359
+ get responseTimestamp() {
1360
+ setRenderKey("responseTimestamp");
1361
+ return state.responseTimestamp;
1307
1362
  },
1308
- onCacheError: callbacks.onError,
1309
- onCacheSuccess: callbacks.onSuccess,
1310
- onCacheChange: callbacks.onFinished
1363
+ get requestTimestamp() {
1364
+ setRenderKey("requestTimestamp");
1365
+ return state.requestTimestamp;
1366
+ }
1311
1367
  }, actions), {
1312
- refetch
1368
+ invalidate
1313
1369
  });
1314
1370
  };
1315
1371
 
1316
1372
  // src/hooks/use-cache/use-cache.constants.ts
1317
1373
  var useCacheDefaultOptions = {
1318
1374
  dependencyTracking: true,
1319
- initialData: null,
1375
+ initialResponse: null,
1320
1376
  deepCompare: true
1321
1377
  };
1322
1378
 
1323
1379
  // src/hooks/use-listener/use-listener.hooks.ts
1324
- import { useRef as useRef8 } from "react";
1325
- import { useDidUpdate as useDidUpdate6, useWillUnmount as useWillUnmount3 } from "@better-hooks/lifecycle";
1380
+ import { useDidUpdate as useDidUpdate5, useWillUnmount as useWillUnmount3 } from "@better-hooks/lifecycle";
1381
+ import { useRef as useRef7 } from "react";
1326
1382
  var useListener = (listener, options) => {
1327
- const [globalConfig] = useConfigProvider();
1383
+ const { config: globalConfig } = useProvider();
1328
1384
  const { dependencyTracking } = __spreadValues(__spreadValues({}, globalConfig.useListener), options);
1329
1385
  const [state, actions, callbacks, { setRenderKey }] = useSocketState(listener.socket, { dependencyTracking });
1330
- const removeListenerRef = useRef8(null);
1331
- const onEventCallback = useRef8(null);
1386
+ const removeListenerRef = useRef7(null);
1387
+ const onEventCallback = useRef7(null);
1332
1388
  const stopListener = () => {
1333
1389
  var _a;
1334
1390
  (_a = removeListenerRef.current) == null ? void 0 : _a.call(removeListenerRef);
1335
1391
  };
1336
1392
  const listen = () => {
1337
1393
  stopListener();
1338
- removeListenerRef.current = listener.listen({
1339
- callback: ({ data, extra }) => {
1340
- var _a;
1341
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, { data, extra });
1342
- actions.setData(data);
1343
- actions.setTimestamp(+new Date());
1344
- }
1394
+ removeListenerRef.current = listener.listen(({ data, extra }) => {
1395
+ var _a;
1396
+ (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, { data, extra });
1397
+ actions.setData(data);
1398
+ actions.setExtra(extra);
1399
+ actions.setTimestamp(+/* @__PURE__ */ new Date());
1345
1400
  });
1346
1401
  };
1347
1402
  const additionalCallbacks = {
@@ -1349,7 +1404,7 @@ var useListener = (listener, options) => {
1349
1404
  onEventCallback.current = callback;
1350
1405
  }
1351
1406
  };
1352
- useDidUpdate6(
1407
+ useDidUpdate5(
1353
1408
  () => {
1354
1409
  listen();
1355
1410
  },
@@ -1364,6 +1419,10 @@ var useListener = (listener, options) => {
1364
1419
  setRenderKey("data");
1365
1420
  return state.data;
1366
1421
  },
1422
+ get extra() {
1423
+ setRenderKey("extra");
1424
+ return state.extra;
1425
+ },
1367
1426
  get connected() {
1368
1427
  setRenderKey("connected");
1369
1428
  return state.connected;
@@ -1382,77 +1441,48 @@ var useListener = (listener, options) => {
1382
1441
  };
1383
1442
 
1384
1443
  // src/hooks/use-emitter/use-emitter.hooks.ts
1385
- import { useRef as useRef9 } from "react";
1444
+ import { useDidUpdate as useDidUpdate6 } from "@better-hooks/lifecycle";
1445
+ import { useRef as useRef8 } from "react";
1386
1446
  var useEmitter = (emitter, options) => {
1387
- const [globalConfig] = useConfigProvider();
1447
+ const { config: globalConfig } = useProvider();
1388
1448
  const { dependencyTracking } = __spreadValues(__spreadValues({}, globalConfig.useEmitter), options);
1389
- const onEventCallback = useRef9(null);
1390
1449
  const [state, actions, callbacks, { setRenderKey }] = useSocketState(emitter.socket, { dependencyTracking });
1391
- const additionalCallbacks = {
1392
- onEvent: (callback) => {
1393
- onEventCallback.current = callback;
1394
- }
1395
- };
1396
- const emit = (emitOptions) => {
1397
- var _a;
1398
- actions.setTimestamp(+new Date());
1399
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, emitter);
1400
- return emitter.emit(emitOptions);
1401
- };
1402
- return __spreadProps(__spreadValues(__spreadValues(__spreadValues({
1403
- get connected() {
1404
- setRenderKey("connected");
1405
- return state.connected;
1406
- },
1407
- get connecting() {
1408
- setRenderKey("connecting");
1409
- return state.connecting;
1410
- },
1411
- get timestamp() {
1412
- setRenderKey("timestamp");
1413
- return state.timestamp;
1414
- }
1415
- }, actions), callbacks), additionalCallbacks), {
1416
- emit,
1417
- reconnect: emitter.socket.reconnect
1418
- });
1419
- };
1420
-
1421
- // src/hooks/use-event-messages/use-event-messages.hooks.ts
1422
- import { useRef as useRef10 } from "react";
1423
- import { useDidUpdate as useDidUpdate7 } from "@better-hooks/lifecycle";
1424
- var useEventMessages = (socket, options) => {
1425
- const [globalConfig] = useConfigProvider();
1426
- const { dependencyTracking = false, filter } = __spreadValues(__spreadValues({}, globalConfig.useEventMessages), options);
1427
- const onEventCallback = useRef10(null);
1428
- const [state, actions, callbacks, { setRenderKey }] = useSocketState(socket, { dependencyTracking });
1429
- useDidUpdate7(
1450
+ const onEventStartCallback = useRef8(null);
1451
+ const onEventErrorCallback = useRef8(null);
1452
+ useDidUpdate6(
1430
1453
  () => {
1431
- const unmountListener = socket.events.onListenerEvent(({ endpoint, data, extra }) => {
1432
- var _a;
1433
- const filterFn = typeof filter === "function" ? () => filter(endpoint, data) : () => filter.includes(endpoint);
1434
- const isFiltered = filter ? filterFn() : false;
1435
- if (!isFiltered) {
1436
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, data, extra);
1437
- actions.setData(data);
1438
- actions.setTimestamp(+new Date());
1439
- }
1440
- });
1441
- return unmountListener;
1454
+ const onEventStart = () => {
1455
+ return emitter.socket.events.onEmitterStartEventByTopic(emitter, () => {
1456
+ var _a;
1457
+ (_a = onEventStartCallback.current) == null ? void 0 : _a.call(onEventStartCallback, emitter);
1458
+ });
1459
+ };
1460
+ const onEventError = () => {
1461
+ return emitter.socket.events.onEmitterErrorByTopic(emitter, ({ error }) => {
1462
+ var _a;
1463
+ (_a = onEventErrorCallback.current) == null ? void 0 : _a.call(onEventErrorCallback, { error });
1464
+ });
1465
+ };
1466
+ const unmountEventStart = onEventStart();
1467
+ const unmountEventError = onEventError();
1468
+ return () => {
1469
+ unmountEventStart();
1470
+ unmountEventError();
1471
+ };
1442
1472
  },
1443
- [socket, filter],
1473
+ [emitter.topic, onEventStartCallback.current, onEventErrorCallback.current],
1444
1474
  true
1445
1475
  );
1446
- const additionalCallbacks = {
1447
- onEvent: (callback) => {
1448
- onEventCallback.current = callback;
1449
- }
1476
+ const emit = (emitOptions) => {
1477
+ return emitter.emit(emitOptions);
1450
1478
  };
1451
- return __spreadValues(__spreadValues(__spreadValues({
1452
- get data() {
1453
- setRenderKey("data");
1454
- return state.data;
1455
- },
1479
+ const onEmit = (callback) => {
1480
+ onEventStartCallback.current = callback;
1481
+ };
1482
+ const onEmitError = (callback) => {
1483
+ onEventErrorCallback.current = callback;
1484
+ };
1485
+ return __spreadProps(__spreadValues(__spreadValues({
1456
1486
  get connected() {
1457
1487
  setRenderKey("connected");
1458
1488
  return state.connected;
@@ -1460,17 +1490,17 @@ var useEventMessages = (socket, options) => {
1460
1490
  get connecting() {
1461
1491
  setRenderKey("connecting");
1462
1492
  return state.connecting;
1463
- },
1464
- get timestamp() {
1465
- setRenderKey("timestamp");
1466
- return state.timestamp;
1467
1493
  }
1468
- }, actions), callbacks), additionalCallbacks);
1494
+ }, actions), callbacks), {
1495
+ onEmit,
1496
+ onEmitError,
1497
+ emit
1498
+ });
1469
1499
  };
1470
1500
 
1471
1501
  // src/hooks/use-app-manager/use-app-manager.hooks.ts
1502
+ import { useDidMount as useDidMount4 } from "@better-hooks/lifecycle";
1472
1503
  import { useState as useState3 } from "react";
1473
- import { useDidMount as useDidMount5 } from "@better-hooks/lifecycle";
1474
1504
  var useAppManager = (client) => {
1475
1505
  const [online, setIsOnline] = useState3(client.appManager.isOnline);
1476
1506
  const [focused, setIsFocused] = useState3(client.appManager.isFocused);
@@ -1492,11 +1522,11 @@ var useAppManager = (client) => {
1492
1522
  const setFocused = (isFocused) => {
1493
1523
  client.appManager.setFocused(isFocused);
1494
1524
  };
1495
- useDidMount5(mountEvents);
1525
+ useDidMount4(mountEvents);
1496
1526
  return { isOnline: online, isFocused: focused, setOnline, setFocused };
1497
1527
  };
1498
1528
  export {
1499
- ConfigProvider,
1529
+ Provider,
1500
1530
  getBounceData,
1501
1531
  getDetailsState,
1502
1532
  getInitialState,
@@ -1512,12 +1542,11 @@ export {
1512
1542
  useAppManager,
1513
1543
  useCache,
1514
1544
  useCacheDefaultOptions,
1515
- useConfigProvider,
1516
1545
  useEmitter,
1517
- useEventMessages,
1518
1546
  useFetch,
1519
1547
  useFetchDefaultOptions,
1520
1548
  useListener,
1549
+ useProvider,
1521
1550
  useQueue,
1522
1551
  useQueueDefaultOptions,
1523
1552
  useRequestEvents,
@@ -1526,4 +1555,4 @@ export {
1526
1555
  useSubmitDefaultOptions,
1527
1556
  useTrackedState
1528
1557
  };
1529
- //# sourceMappingURL=index.esm.js.map
1558
+ //# sourceMappingURL=index.js.map