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