@hyper-fetch/react 6.0.0 → 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 +179 -157
  4. package/dist/{index.esm.js → index.js} +500 -435
  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 +79 -98
  14. package/src/helpers/use-tracked-state/use-tracked-state.types.ts +44 -25
  15. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +79 -34
  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 -82
  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 -1514
  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;
@@ -362,14 +364,40 @@ var getValidCacheData = (request, initialData, cacheData) => {
362
364
  var getTimestamp = (timestamp) => {
363
365
  return timestamp ? new Date(timestamp) : null;
364
366
  };
365
- var getInitialState = (initialData, dispatcher, request) => {
366
- const { client, cacheKey, responseMapper } = request;
367
+ var getIsInitiallyLoading = ({
368
+ queryKey,
369
+ dispatcher,
370
+ hasState,
371
+ revalidate,
372
+ disabled
373
+ }) => {
374
+ if (!revalidate && hasState) {
375
+ return false;
376
+ }
377
+ const queue = dispatcher.getQueue(queryKey);
378
+ const isInitiallyLoading = dispatcher.hasRunningRequests(queryKey) || !queue.stopped && disabled === false;
379
+ return isInitiallyLoading;
380
+ };
381
+ var getInitialState = ({
382
+ initialResponse,
383
+ dispatcher,
384
+ request,
385
+ disabled,
386
+ revalidate
387
+ }) => {
388
+ const { client, cacheKey, unstable_responseMapper } = request;
367
389
  const { cache } = client;
368
390
  const cacheData = cache.get(cacheKey);
369
- const cacheState = getValidCacheData(request, initialData, cacheData);
370
- const initialLoading = dispatcher.hasRunningRequests(request.queueKey);
391
+ const cacheState = getValidCacheData(request, initialResponse, cacheData);
392
+ const initialLoading = getIsInitiallyLoading({
393
+ queryKey: request.queryKey,
394
+ dispatcher,
395
+ disabled,
396
+ revalidate,
397
+ hasState: !!cacheState
398
+ });
371
399
  if (cacheState) {
372
- const mappedData = responseMapper ? responseMapper(cacheState) : cacheState;
400
+ const mappedData = unstable_responseMapper ? unstable_responseMapper(cacheState) : cacheState;
373
401
  if (mappedData instanceof Promise) {
374
402
  return initialState;
375
403
  }
@@ -378,9 +406,10 @@ var getInitialState = (initialData, dispatcher, request) => {
378
406
  error: mappedData.error,
379
407
  status: mappedData.status,
380
408
  success: mappedData.success,
381
- extra: mappedData.extra,
409
+ extra: mappedData.extra || client.adapter.defaultExtra,
382
410
  retries: cacheState.retries,
383
- timestamp: getTimestamp(cacheState.timestamp),
411
+ requestTimestamp: getTimestamp(cacheState.requestTimestamp),
412
+ responseTimestamp: getTimestamp(cacheState.responseTimestamp),
384
413
  loading: initialLoading
385
414
  };
386
415
  }
@@ -389,9 +418,10 @@ var getInitialState = (initialData, dispatcher, request) => {
389
418
  error: initialState.error,
390
419
  status: initialState.status,
391
420
  success: initialState.success,
392
- extra: request.client.defaultExtra,
421
+ extra: request.client.adapter.defaultExtra,
393
422
  retries: initialState.retries,
394
- timestamp: getTimestamp(initialState.timestamp),
423
+ requestTimestamp: getTimestamp(initialState.requestTimestamp),
424
+ responseTimestamp: getTimestamp(initialState.responseTimestamp),
395
425
  loading: initialLoading
396
426
  };
397
427
  };
@@ -400,20 +430,21 @@ var getInitialState = (initialData, dispatcher, request) => {
400
430
  var useTrackedState = ({
401
431
  request,
402
432
  dispatcher,
403
- initialData,
433
+ initialResponse,
404
434
  deepCompare,
405
435
  dependencyTracking,
406
- defaultCacheEmitting = true
436
+ disabled,
437
+ revalidate
407
438
  }) => {
408
- const { client, cacheKey, queueKey, cacheTime, responseMapper } = request;
409
- const { cache, requestManager } = client;
439
+ const { client, cacheKey, queryKey, staleTime, unstable_responseMapper } = request;
440
+ const { cache } = client;
410
441
  const forceUpdate = useForceUpdate();
411
- const state = useRef2(getInitialState(initialData, dispatcher, request));
442
+ const state = useRef2(getInitialState({ initialResponse, dispatcher, request, disabled }));
412
443
  const renderKeys = useRef2([]);
413
444
  const isProcessingData = useRef2("");
414
445
  const getStaleStatus = () => {
415
446
  const cacheData = cache.get(cacheKey);
416
- return !cacheData || isStaleCacheData(cacheTime, cacheData == null ? void 0 : cacheData.timestamp);
447
+ return !cacheData || isStaleCacheData(staleTime, cacheData == null ? void 0 : cacheData.responseTimestamp);
417
448
  };
418
449
  const renderKeyTrigger = (keys) => {
419
450
  const shouldRerender = renderKeys.current.some((renderKey) => keys.includes(renderKey));
@@ -427,18 +458,20 @@ var useTrackedState = ({
427
458
  };
428
459
  useDidUpdate(
429
460
  () => {
430
- state.current.loading = dispatcher.hasRunningRequests(queueKey);
431
461
  const cacheData = cache.get(cacheKey);
432
- const cacheState = getValidCacheData(request, initialData, cacheData);
433
- const hasInitialState = isEqual(initialData == null ? void 0 : initialData.data, state.current.data);
434
- const hasState = !!(state.current.data || state.current.error) && !hasInitialState;
435
- const shouldLoadInitialCache = !hasState && !!state.current.data;
436
- const shouldRemovePreviousData = hasState && !state.current.data;
437
- if (cacheState || shouldLoadInitialCache || shouldRemovePreviousData) {
462
+ const cacheState = getValidCacheData(request, initialResponse, cacheData);
463
+ state.current.loading = getIsInitiallyLoading({
464
+ queryKey: request.queryKey,
465
+ dispatcher,
466
+ disabled,
467
+ revalidate,
468
+ hasState: !!cacheState
469
+ });
470
+ if (cacheState) {
438
471
  setCacheData(cacheState);
439
472
  }
440
473
  },
441
- [cacheKey, queueKey],
474
+ [cacheKey, queryKey],
442
475
  true
443
476
  );
444
477
  useDidUpdate(
@@ -470,8 +503,9 @@ var useTrackedState = ({
470
503
  success: cacheData.success,
471
504
  extra: cacheData.extra,
472
505
  retries: cacheData.retries,
473
- timestamp: new Date(cacheData.timestamp),
474
- loading: dispatcher.hasRunningRequests(queueKey)
506
+ responseTimestamp: new Date(cacheData.responseTimestamp),
507
+ requestTimestamp: new Date(cacheData.requestTimestamp),
508
+ loading: dispatcher.hasRunningRequests(queryKey)
475
509
  };
476
510
  const changedKeys = Object.keys(newStateValues).filter((key) => {
477
511
  const keyValue = key;
@@ -497,7 +531,7 @@ var useTrackedState = ({
497
531
  };
498
532
  const setCacheData = (cacheData) => {
499
533
  setIsDataProcessing({ processingCacheKey: cacheKey, isProcessing: true });
500
- const data = responseMapper ? responseMapper(cacheData) : cacheData;
534
+ const data = unstable_responseMapper ? unstable_responseMapper(cacheData) : cacheData;
501
535
  if (data instanceof Promise) {
502
536
  return (() => __async(void 0, null, function* () {
503
537
  const promiseData = yield data;
@@ -509,98 +543,84 @@ var useTrackedState = ({
509
543
  return handleCacheData(__spreadValues(__spreadValues({}, cacheData), data));
510
544
  };
511
545
  const actions = {
512
- setData: (data, emitToCache = defaultCacheEmitting) => {
513
- if (emitToCache) {
514
- const currentState = state.current;
515
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success: true, data }));
516
- } else {
517
- state.current.data = data;
518
- renderKeyTrigger(["data"]);
519
- }
546
+ setData: (data) => {
547
+ state.current.data = data instanceof Function ? data(state.current.data || null) : data;
548
+ renderKeyTrigger(["data"]);
520
549
  },
521
- setError: (error, emitToCache = defaultCacheEmitting) => {
522
- if (emitToCache) {
523
- const currentState = state.current;
524
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success: false, error }));
525
- } else {
526
- state.current.error = error;
527
- renderKeyTrigger(["error"]);
528
- }
550
+ setError: (error) => {
551
+ state.current.error = error instanceof Function ? error(state.current.error || null) : error;
552
+ renderKeyTrigger(["error"]);
529
553
  },
530
- setLoading: (loading, emitToHooks = true) => {
531
- if (emitToHooks) {
532
- requestManager.events.emitLoading(queueKey, "", {
533
- queueKey,
534
- requestId: "",
535
- loading,
536
- isRetry: false,
537
- isOffline: false
538
- });
539
- } else {
540
- state.current.loading = loading;
541
- renderKeyTrigger(["loading"]);
542
- }
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"]);
543
560
  },
544
- setStatus: (status, emitToCache = defaultCacheEmitting) => {
545
- if (emitToCache) {
546
- const currentState = state.current;
547
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { status }));
548
- } else {
549
- state.current.status = status;
550
- renderKeyTrigger(["status"]);
551
- }
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"]);
552
567
  },
553
- setSuccess: (success, emitToCache = defaultCacheEmitting) => {
554
- if (emitToCache) {
555
- const currentState = state.current;
556
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { success }));
557
- } else {
558
- state.current.success = success;
559
- renderKeyTrigger(["success"]);
560
- }
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"]);
561
574
  },
562
- setExtra: (extra, emitToCache = defaultCacheEmitting) => {
563
- if (emitToCache) {
564
- const currentState = state.current;
565
- cache.set(request, __spreadProps(__spreadValues(__spreadValues({}, currentState), getDetailsState(state.current)), { extra }));
566
- } else {
567
- state.current.extra = extra;
568
- renderKeyTrigger(["extra"]);
569
- }
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"]);
570
581
  },
571
- setRetries: (retries, emitToCache = defaultCacheEmitting) => {
572
- if (emitToCache) {
573
- const currentState = state.current;
574
- cache.set(request, __spreadValues(__spreadValues({}, currentState), getDetailsState(state.current, { retries })));
575
- } else {
576
- state.current.retries = retries;
577
- renderKeyTrigger(["retries"]);
578
- }
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"]);
579
588
  },
580
- setTimestamp: (timestamp, emitToCache = defaultCacheEmitting) => {
581
- if (emitToCache) {
582
- const currentState = state.current;
583
- cache.set(request, __spreadValues(__spreadValues({}, currentState), getDetailsState(state.current, { timestamp: +timestamp })));
584
- } else {
585
- state.current.timestamp = timestamp;
586
- renderKeyTrigger(["timestamp"]);
587
- }
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"]);
588
608
  }
589
609
  };
590
610
  return [state.current, actions, { setRenderKey, setCacheData, getStaleStatus, getIsDataProcessing }];
591
611
  };
592
612
 
593
613
  // src/helpers/use-socket-state/use-socket-state.hooks.ts
594
- import { useRef as useRef3 } from "react";
595
614
  import { useDidMount, useDidUpdate as useDidUpdate2, useForceUpdate as useForceUpdate2 } from "@better-hooks/lifecycle";
615
+ import { useRef as useRef3 } from "react";
596
616
  var useSocketState = (socket, { dependencyTracking }) => {
597
617
  const forceUpdate = useForceUpdate2();
598
- const onOpenCallback = useRef3(null);
599
- const onCloseCallback = useRef3(null);
618
+ const onDisconnectCallback = useRef3(null);
600
619
  const onErrorCallback = useRef3(null);
620
+ const onConnectedCallback = useRef3(null);
601
621
  const onConnectingCallback = useRef3(null);
602
622
  const onReconnectingCallback = useRef3(null);
603
- const onReconnectingStopCallback = useRef3(null);
623
+ const onReconnectingFailedCallback = useRef3(null);
604
624
  const state = useRef3(initialSocketState);
605
625
  const renderKeys = useRef3([]);
606
626
  const renderKeyTrigger = (keys) => {
@@ -615,6 +635,8 @@ var useSocketState = (socket, { dependencyTracking }) => {
615
635
  };
616
636
  useDidUpdate2(
617
637
  () => {
638
+ state.current.connected = socket.adapter.connected;
639
+ state.current.connecting = socket.adapter.connecting;
618
640
  const handleDependencyTracking = () => {
619
641
  if (!dependencyTracking) {
620
642
  Object.keys(state.current).forEach((key) => setRenderKey(key));
@@ -630,6 +652,10 @@ var useSocketState = (socket, { dependencyTracking }) => {
630
652
  state.current.data = data;
631
653
  renderKeyTrigger(["data"]);
632
654
  },
655
+ setExtra: (extra) => {
656
+ state.current.extra = extra;
657
+ renderKeyTrigger(["extra"]);
658
+ },
633
659
  setConnected: (connected) => {
634
660
  state.current.connected = connected;
635
661
  renderKeyTrigger(["data"]);
@@ -644,11 +670,11 @@ var useSocketState = (socket, { dependencyTracking }) => {
644
670
  }
645
671
  };
646
672
  const callbacks = {
647
- onOpen: (callback) => {
648
- onOpenCallback.current = callback;
673
+ onConnected: (callback) => {
674
+ onConnectedCallback.current = callback;
649
675
  },
650
- onClose: (callback) => {
651
- onCloseCallback.current = callback;
676
+ onDisconnected: (callback) => {
677
+ onDisconnectCallback.current = callback;
652
678
  },
653
679
  onError: (callback) => {
654
680
  onErrorCallback.current = callback;
@@ -659,8 +685,8 @@ var useSocketState = (socket, { dependencyTracking }) => {
659
685
  onReconnecting: (callback) => {
660
686
  onReconnectingCallback.current = callback;
661
687
  },
662
- onReconnectingStop: (callback) => {
663
- onReconnectingStopCallback.current = callback;
688
+ onReconnectingFailed: (callback) => {
689
+ onReconnectingFailedCallback.current = callback;
664
690
  }
665
691
  };
666
692
  useDidMount(() => {
@@ -668,28 +694,28 @@ var useSocketState = (socket, { dependencyTracking }) => {
668
694
  var _a;
669
695
  (_a = onErrorCallback.current) == null ? void 0 : _a.call(onErrorCallback, event);
670
696
  });
671
- const umountOnConnecting = socket.events.onConnecting(() => {
697
+ const umountOnConnecting = socket.events.onConnecting(({ connecting }) => {
672
698
  var _a;
673
- actions.setConnecting(true);
699
+ actions.setConnecting(connecting);
674
700
  (_a = onConnectingCallback.current) == null ? void 0 : _a.call(onConnectingCallback);
675
701
  });
676
- const umountOnOpen = socket.events.onOpen(() => {
702
+ const umountOnOpen = socket.events.onConnected(() => {
677
703
  var _a;
678
704
  actions.setConnected(true);
679
- (_a = onOpenCallback.current) == null ? void 0 : _a.call(onOpenCallback);
705
+ (_a = onConnectedCallback.current) == null ? void 0 : _a.call(onConnectedCallback);
680
706
  });
681
- const umountOnClose = socket.events.onClose(() => {
707
+ const umountOnClose = socket.events.onDisconnected(() => {
682
708
  var _a;
683
709
  actions.setConnected(false);
684
- (_a = onCloseCallback.current) == null ? void 0 : _a.call(onCloseCallback);
710
+ (_a = onDisconnectCallback.current) == null ? void 0 : _a.call(onDisconnectCallback);
685
711
  });
686
- const umountOnReconnecting = socket.events.onReconnecting((attempts) => {
712
+ const umountOnReconnecting = socket.events.onReconnecting(({ attempts }) => {
687
713
  var _a;
688
- (_a = onReconnectingCallback.current) == null ? void 0 : _a.call(onReconnectingCallback, attempts);
714
+ (_a = onReconnectingCallback.current) == null ? void 0 : _a.call(onReconnectingCallback, { attempts });
689
715
  });
690
- const umountOnReconnectingStop = socket.events.onReconnectingStop((attempts) => {
716
+ const umountOnReconnectingFailed = socket.events.onReconnectingFailed(({ attempts }) => {
691
717
  var _a;
692
- (_a = onReconnectingStopCallback.current) == null ? void 0 : _a.call(onReconnectingStopCallback, attempts);
718
+ (_a = onReconnectingFailedCallback.current) == null ? void 0 : _a.call(onReconnectingFailedCallback, { attempts });
693
719
  });
694
720
  return () => {
695
721
  umountOnError();
@@ -697,7 +723,7 @@ var useSocketState = (socket, { dependencyTracking }) => {
697
723
  umountOnOpen();
698
724
  umountOnClose();
699
725
  umountOnReconnecting();
700
- umountOnReconnectingStop();
726
+ umountOnReconnectingFailed();
701
727
  };
702
728
  });
703
729
  return [state.current, actions, callbacks, { setRenderKey }];
@@ -706,66 +732,72 @@ var useSocketState = (socket, { dependencyTracking }) => {
706
732
  // src/helpers/use-socket-state/use-socket-state.constants.ts
707
733
  var initialSocketState = {
708
734
  data: null,
735
+ extra: null,
709
736
  connected: false,
710
737
  connecting: false,
711
738
  timestamp: null
712
739
  };
713
740
 
714
- // src/config-provider/config-provider.tsx
741
+ // src/provider/provider.tsx
715
742
  import React, { useContext, useMemo, useState } from "react";
716
743
  import { jsx } from "react/jsx-runtime";
717
- var ConfigContext = React.createContext([{}, () => null]);
718
- var ConfigProvider = ({ children, config }) => {
744
+ var ConfigContext = React.createContext({
745
+ config: {},
746
+ setConfig: () => null
747
+ });
748
+ var Provider = ({ children, config }) => {
719
749
  const [currentConfig, setConfig] = useState(config || {});
720
750
  const value = useMemo(() => {
721
- const contextValue = [currentConfig, setConfig];
751
+ const contextValue = { config: currentConfig, setConfig };
722
752
  return contextValue;
723
753
  }, [currentConfig]);
724
754
  return /* @__PURE__ */ jsx(ConfigContext.Provider, { value, children });
725
755
  };
726
- var useConfigProvider = () => {
756
+ var useProvider = () => {
727
757
  const config = useContext(ConfigContext);
728
758
  return config;
729
759
  };
730
760
 
731
761
  // src/hooks/use-fetch/use-fetch.hooks.ts
732
- var useFetch = (request, options = useFetchDefaultOptions) => {
733
- const [globalConfig] = useConfigProvider();
762
+ var useFetch = (request, options) => {
763
+ const { config: globalConfig } = useProvider();
734
764
  const {
735
- dependencies = useFetchDefaultOptions.dependencies,
736
- disabled = useFetchDefaultOptions.disabled,
737
- dependencyTracking = useFetchDefaultOptions.dependencyTracking,
738
- revalidate = useFetchDefaultOptions.revalidate,
739
- initialData = useFetchDefaultOptions.initialData,
740
- refresh = useFetchDefaultOptions.refresh,
741
- refreshTime = useFetchDefaultOptions.refreshTime,
742
- refetchBlurred = useFetchDefaultOptions.refetchBlurred,
743
- refetchOnBlur = useFetchDefaultOptions.refetchOnBlur,
744
- refetchOnFocus = useFetchDefaultOptions.refetchOnFocus,
745
- refetchOnReconnect = useFetchDefaultOptions.refetchOnReconnect,
746
- bounce = useFetchDefaultOptions.bounce,
747
- bounceType = useFetchDefaultOptions.bounceType,
748
- bounceTime = useFetchDefaultOptions.bounceTime,
749
- bounceTimeout = useFetchDefaultOptions.bounceTime,
750
- 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
751
781
  } = __spreadValues(__spreadValues(__spreadValues({}, useFetchDefaultOptions), globalConfig.useFetchConfig), options);
752
782
  const updateKey = JSON.stringify(request.toJSON());
753
783
  const requestDebounce = useDebounce({ delay: bounceTime });
754
784
  const requestThrottle = useThrottle({ interval: bounceTime, timeout: bounceTimeout });
755
785
  const refreshDebounce = useDebounce({ delay: refreshTime });
756
- const { cacheKey, queueKey, client } = request;
786
+ const { cacheKey, queryKey, client } = request;
757
787
  const { cache, fetchDispatcher: dispatcher, appManager, loggerManager } = client;
758
788
  const ignoreReact18DoubleRender = useRef4(true);
759
- const logger = useRef4(loggerManager.init("useFetch")).current;
789
+ const logger = useRef4(loggerManager.initialize(client, "useFetch")).current;
760
790
  const bounceData = bounceType === "throttle" ? requestThrottle : requestDebounce;
761
791
  const bounceFunction = bounceType === "throttle" ? requestThrottle.throttle : requestDebounce.debounce;
762
792
  const [state, actions, { setRenderKey, setCacheData, getStaleStatus, getIsDataProcessing }] = useTrackedState({
763
793
  logger,
764
794
  request,
765
795
  dispatcher,
766
- initialData,
796
+ initialResponse,
767
797
  deepCompare,
768
- dependencyTracking
798
+ dependencyTracking,
799
+ disabled,
800
+ revalidate
769
801
  });
770
802
  const [callbacks, listeners] = useRequestEvents({
771
803
  logger,
@@ -778,14 +810,10 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
778
810
  const { addCacheDataListener, addLifecycleListeners, clearCacheDataListener } = listeners;
779
811
  const handleFetch = () => {
780
812
  if (!disabled) {
781
- logger.debug(`Fetching data`);
813
+ logger.debug({ title: `Fetching data`, type: "system", extra: { request } });
782
814
  dispatcher.add(request);
783
- const queue = dispatcher.getQueue(request.queueKey);
784
- if (!queue.stopped && queue.requests.length) {
785
- actions.setLoading(true);
786
- }
787
815
  } else {
788
- logger.debug(`Cannot add to fetch queue`, { disabled });
816
+ logger.debug({ title: `Cannot add to fetch queue`, type: "system", extra: { disabled } });
789
817
  }
790
818
  };
791
819
  function handleRefresh() {
@@ -795,37 +823,24 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
795
823
  }
796
824
  refreshDebounce.debounce(() => {
797
825
  const isBlurred = !appManager.isFocused;
798
- const isFetching = dispatcher.hasRunningRequests(request.queueKey);
799
- const isQueued = dispatcher.getIsActiveQueue(request.queueKey);
826
+ const isFetching = dispatcher.hasRunningRequests(request.queryKey);
827
+ const isQueued = dispatcher.getIsActiveQueue(request.queryKey);
800
828
  const isActive = isFetching || isQueued;
801
829
  const canRefreshBlurred = isBlurred && refetchBlurred && !isActive;
802
830
  const canRefreshFocused = !isBlurred && !isActive;
803
831
  if (canRefreshBlurred || canRefreshFocused) {
804
832
  handleFetch();
805
- logger.debug(`Performing refresh request`);
833
+ logger.debug({ title: `Performing refresh request`, type: "system", extra: { request } });
806
834
  }
807
835
  handleRefresh();
808
836
  });
809
837
  }
810
- const handleInvalidation = (invalidateKey) => {
811
- if (invalidateKey && invalidateKey instanceof Request) {
812
- cache.invalidate(getRequestKey(invalidateKey));
813
- } else if (invalidateKey && !(invalidateKey instanceof Request)) {
814
- cache.invalidate(invalidateKey);
815
- }
816
- };
817
- const refetch = (invalidateKey) => {
818
- if (invalidateKey && Array.isArray(invalidateKey)) {
819
- invalidateKey.forEach(handleInvalidation);
820
- } else if (invalidateKey && !Array.isArray(invalidateKey)) {
821
- handleInvalidation(invalidateKey);
822
- } else {
823
- handleFetch();
824
- handleRefresh();
825
- }
838
+ const refetch = () => {
839
+ handleFetch();
840
+ handleRefresh();
826
841
  };
827
842
  const getIsFetchingIdentity = () => {
828
- return dispatcher.getRunningRequests(queueKey).some((running) => running.request.cacheKey === cacheKey);
843
+ return dispatcher.getRunningRequests(queryKey).some((running) => running.request.cacheKey === cacheKey);
829
844
  };
830
845
  const initialFetchData = () => {
831
846
  const hasStaleData = getStaleStatus();
@@ -839,7 +854,7 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
839
854
  const shouldUpdate = !revalidate ? hasStaleData : true;
840
855
  if (!ignoreReact18DoubleRender.current && shouldUpdate) {
841
856
  if (bounce) {
842
- logger.debug(`Bounce request with ${bounceType}`, { queueKey, request });
857
+ logger.debug({ title: `Bounce request with ${bounceType}`, type: "system", extra: { queryKey, request } });
843
858
  bounceFunction(() => handleFetch());
844
859
  } else {
845
860
  handleFetch();
@@ -869,13 +884,15 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
869
884
  handleRefresh();
870
885
  }
871
886
  });
872
- const invalidateUnmount = cache.events.onInvalidate(cacheKey, handleFetch);
887
+ const invalidateUnmount = cache.events.onInvalidateByKey(cacheKey, handleFetch);
888
+ const deletionUnmount = cache.events.onDeleteByKey(cacheKey, handleFetch);
873
889
  const unmount = () => {
874
890
  clearCacheDataListener();
875
891
  focusUnmount();
876
892
  blurUnmount();
877
893
  onlineUnmount();
878
894
  invalidateUnmount();
895
+ deletionUnmount();
879
896
  };
880
897
  return unmount;
881
898
  };
@@ -915,9 +932,13 @@ var useFetch = (request, options = useFetchDefaultOptions) => {
915
932
  setRenderKey("retries");
916
933
  return state.retries;
917
934
  },
918
- get timestamp() {
919
- setRenderKey("timestamp");
920
- return state.timestamp;
935
+ get responseTimestamp() {
936
+ setRenderKey("responseTimestamp");
937
+ return state.responseTimestamp;
938
+ },
939
+ get requestTimestamp() {
940
+ setRenderKey("requestTimestamp");
941
+ return state.requestTimestamp;
921
942
  },
922
943
  bounce: getBounceData(bounceData)
923
944
  }, actions), callbacks), {
@@ -935,15 +956,15 @@ var getRefreshTime = (refreshTime, dataTimestamp) => {
935
956
  };
936
957
 
937
958
  // src/hooks/use-fetch/use-fetch.constants.ts
938
- import { DateInterval } from "@hyper-fetch/core";
959
+ import { Time } from "@hyper-fetch/core";
939
960
  var useFetchDefaultOptions = {
940
961
  dependencies: [],
941
962
  disabled: false,
942
963
  dependencyTracking: true,
943
964
  revalidate: true,
944
- initialData: null,
965
+ initialResponse: null,
945
966
  refresh: false,
946
- refreshTime: DateInterval.hour,
967
+ refreshTime: Time.HOUR,
947
968
  refetchBlurred: true,
948
969
  refetchOnBlur: false,
949
970
  refetchOnFocus: false,
@@ -951,28 +972,28 @@ var useFetchDefaultOptions = {
951
972
  bounce: false,
952
973
  bounceType: "debounce",
953
974
  bounceTime: 400,
975
+ bounceTimeout: 400,
954
976
  deepCompare: true
955
977
  };
956
978
 
957
979
  // src/hooks/use-submit/use-submit.hooks.ts
958
- import { useMemo as useMemo2, useRef as useRef5 } from "react";
959
980
  import {
960
- Request as Request2,
961
- getRequestKey as getRequestKey2,
962
981
  sendRequest
963
982
  } from "@hyper-fetch/core";
964
983
  import { useDidMount as useDidMount3 } from "@better-hooks/lifecycle";
965
984
  import { useDebounce as useDebounce2, useThrottle as useThrottle2 } from "@better-hooks/performance";
966
- var useSubmit = (request, options = useSubmitDefaultOptions) => {
967
- const [globalConfig] = useConfigProvider();
985
+ import { useMemo as useMemo2, useRef as useRef5 } from "react";
986
+ var useSubmit = (request, options) => {
987
+ const { config: globalConfig } = useProvider();
968
988
  const mergedOptions = useMemo2(
969
989
  () => __spreadValues(__spreadValues(__spreadValues({}, useSubmitDefaultOptions), globalConfig.useSubmitConfig), options),
970
- [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]
971
992
  );
972
- const { disabled, dependencyTracking, initialData, bounce, bounceType, bounceTime, deepCompare } = mergedOptions;
993
+ const { disabled, dependencyTracking, initialResponse, bounce, bounceType, bounceTime, deepCompare } = mergedOptions;
973
994
  const { client } = request;
974
995
  const { cache, submitDispatcher: dispatcher, loggerManager } = client;
975
- const logger = useRef5(loggerManager.init("useSubmit")).current;
996
+ const logger = useRef5(loggerManager.initialize(client, "useSubmit")).current;
976
997
  const requestDebounce = useDebounce2({ delay: bounceTime });
977
998
  const requestThrottle = useThrottle2({
978
999
  interval: bounceTime,
@@ -985,7 +1006,7 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
985
1006
  logger,
986
1007
  request,
987
1008
  dispatcher,
988
- initialData,
1009
+ initialResponse,
989
1010
  deepCompare,
990
1011
  dependencyTracking
991
1012
  });
@@ -1001,29 +1022,30 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1001
1022
  const handleSubmit = (submitOptions) => {
1002
1023
  const requestClone = request.clone(submitOptions);
1003
1024
  if (disabled) {
1004
- logger.warning(`Cannot submit request`, { disabled, submitOptions });
1025
+ logger.warning({ title: `Cannot submit request`, type: "system", extra: { disabled, submitOptions } });
1005
1026
  return Promise.resolve({
1006
1027
  data: null,
1007
1028
  error: new Error("Cannot submit request. Option 'disabled' is enabled"),
1008
1029
  status: null,
1009
- extra: request.client.defaultExtra
1030
+ extra: request.client.adapter.defaultExtra
1010
1031
  });
1011
1032
  }
1012
1033
  const triggerRequest = () => {
1013
1034
  addCacheDataListener(requestClone);
1014
- return sendRequest(requestClone, __spreadProps(__spreadValues({
1035
+ const configuration = __spreadProps(__spreadValues({
1015
1036
  dispatcherType: "submit"
1016
1037
  }, submitOptions), {
1017
- onSettle: (requestId, cmd) => {
1038
+ onBeforeSent: (data) => {
1018
1039
  var _a;
1019
- addLifecycleListeners(requestClone, requestId);
1020
- (_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);
1021
1042
  }
1022
- }));
1043
+ });
1044
+ return sendRequest(requestClone, configuration);
1023
1045
  };
1024
1046
  return new Promise((resolve) => {
1025
1047
  const performSubmit = () => __async(void 0, null, function* () {
1026
- logger.debug(`Submitting request`, { disabled, submitOptions });
1048
+ logger.debug({ title: `Submitting request`, type: "system", extra: { disabled, submitOptions } });
1027
1049
  if (bounce) {
1028
1050
  const bouncedResolve = bounceResolver.current;
1029
1051
  bounceResolver.current = (value) => {
@@ -1044,21 +1066,8 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1044
1066
  performSubmit();
1045
1067
  });
1046
1068
  };
1047
- const handleInvalidation = (invalidateKey) => {
1048
- if (invalidateKey && invalidateKey instanceof Request2) {
1049
- cache.invalidate(getRequestKey2(invalidateKey));
1050
- } else if (invalidateKey && !(invalidateKey instanceof Request2)) {
1051
- cache.invalidate(invalidateKey);
1052
- }
1053
- };
1054
- const refetch = (invalidateKey) => {
1055
- if (!invalidateKey)
1056
- return;
1057
- if (invalidateKey && Array.isArray(invalidateKey)) {
1058
- invalidateKey.forEach(handleInvalidation);
1059
- } else if (invalidateKey && !Array.isArray(invalidateKey)) {
1060
- handleInvalidation(invalidateKey);
1061
- }
1069
+ const refetch = () => {
1070
+ cache.invalidate(request);
1062
1071
  };
1063
1072
  const handlers = {
1064
1073
  onSubmitSuccess: callbacks.onSuccess,
@@ -1104,9 +1113,13 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1104
1113
  setRenderKey("retries");
1105
1114
  return state.retries;
1106
1115
  },
1107
- get timestamp() {
1108
- setRenderKey("timestamp");
1109
- return state.timestamp;
1116
+ get responseTimestamp() {
1117
+ setRenderKey("responseTimestamp");
1118
+ return state.responseTimestamp;
1119
+ },
1120
+ get requestTimestamp() {
1121
+ setRenderKey("requestTimestamp");
1122
+ return state.requestTimestamp;
1110
1123
  },
1111
1124
  abort: callbacks.abort
1112
1125
  }, actions), handlers), {
@@ -1119,7 +1132,7 @@ var useSubmit = (request, options = useSubmitDefaultOptions) => {
1119
1132
  var useSubmitDefaultOptions = {
1120
1133
  disabled: false,
1121
1134
  dependencyTracking: true,
1122
- initialData: null,
1135
+ initialResponse: null,
1123
1136
  bounce: false,
1124
1137
  bounceType: "debounce",
1125
1138
  bounceTime: 400,
@@ -1127,94 +1140,167 @@ var useSubmitDefaultOptions = {
1127
1140
  };
1128
1141
 
1129
1142
  // src/hooks/use-queue/use-queue.hooks.ts
1130
- import { useState as useState2, useRef as useRef6 } from "react";
1131
1143
  import { getRequestDispatcher } from "@hyper-fetch/core";
1132
- import { useDidMount as useDidMount4, useDidUpdate as useDidUpdate4 } from "@better-hooks/lifecycle";
1133
- var useQueue = (request, options = useQueueDefaultOptions) => {
1134
- const [globalConfig] = useConfigProvider();
1135
- const { queueType = "auto" } = __spreadValues(__spreadValues(__spreadValues({}, useQueueDefaultOptions), globalConfig.useQueueConfig), options);
1136
- 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;
1137
1155
  const { requestManager } = client;
1138
- const [dispatcher] = getRequestDispatcher(request, queueType);
1139
- const unmountCallbacks = useRef6(null);
1156
+ const [dispatcher] = getRequestDispatcher(request, dispatcherType);
1140
1157
  const [stopped, setStopped] = useState2(false);
1141
1158
  const [requests, setRequests] = useState2([]);
1142
- const createRequestsArray = (queueElements) => {
1143
- return queueElements.map((req) => __spreadProps(__spreadValues({}, req), {
1144
- stopRequest: () => dispatcher.stopRequest(queueKey, req.requestId),
1145
- startRequest: () => dispatcher.startRequest(queueKey, req.requestId),
1146
- deleteRequest: () => dispatcher.delete(queueKey, req.requestId, abortKey)
1147
- }));
1148
- };
1149
- const mergePayloadType = (requestId, data) => {
1150
- setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadValues(__spreadValues({}, el), data) : el));
1151
- };
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
+ }, []);
1152
1204
  const getInitialState2 = () => {
1153
- const requestQueue = dispatcher.getQueue(queueKey);
1205
+ const requestQueue = dispatcher.getQueue(queryKey);
1154
1206
  setStopped(requestQueue.stopped);
1155
1207
  setRequests(createRequestsArray(requestQueue.requests));
1156
1208
  };
1157
- const updateQueueState = (values) => {
1158
- setStopped(values.stopped);
1159
- setRequests(createRequestsArray(values.requests));
1160
- };
1209
+ const updateQueueState = useCallback(
1210
+ (values) => {
1211
+ setStopped(values.stopped);
1212
+ setRequests((prev) => createRequestsArray(values.requests, prev));
1213
+ },
1214
+ [createRequestsArray]
1215
+ );
1161
1216
  const mountEvents = () => {
1162
- var _a;
1163
- const unmountChange = dispatcher.events.onQueueChange(queueKey, updateQueueState);
1164
- const unmountStatus = dispatcher.events.onQueueStatus(queueKey, updateQueueState);
1165
- const unmountDownload = requestManager.events.onDownloadProgress(queueKey, (progress, { requestId }) => {
1166
- 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
+ }
1225
+ });
1226
+ const unmountCanceled = requestManager.events.onAbort(({ requestId }) => {
1227
+ setRequests((prev) => prev.map((el) => el.requestId === requestId ? __spreadProps(__spreadValues({}, el), { canceled: true }) : el));
1167
1228
  });
1168
- const unmountUpload = requestManager.events.onUploadProgress(queueKey, (progress, { requestId }) => {
1169
- mergePayloadType(requestId, { uploading: progress });
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
+ );
1170
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
+ );
1171
1244
  const unmount = () => {
1172
1245
  unmountStatus();
1173
1246
  unmountChange();
1174
1247
  unmountDownload();
1175
1248
  unmountUpload();
1249
+ unmountFailed();
1250
+ unmountCanceled();
1251
+ unmountRemoved();
1176
1252
  };
1177
- (_a = unmountCallbacks.current) == null ? void 0 : _a.call(unmountCallbacks);
1178
- unmountCallbacks.current = unmount;
1179
1253
  return unmount;
1180
1254
  };
1181
- useDidMount4(getInitialState2);
1182
- 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
+ ]);
1183
1267
  return {
1184
1268
  stopped,
1185
1269
  requests,
1186
- stop: () => dispatcher.stop(queueKey),
1187
- pause: () => dispatcher.pause(queueKey),
1188
- start: () => dispatcher.start(queueKey)
1270
+ dispatcher,
1271
+ stop: () => dispatcher.stop(queryKey),
1272
+ pause: () => dispatcher.pause(queryKey),
1273
+ start: () => dispatcher.start(queryKey)
1189
1274
  };
1190
1275
  };
1191
1276
 
1192
1277
  // src/hooks/use-queue/use-queue.constants.ts
1193
1278
  var useQueueDefaultOptions = {
1194
- queueType: "auto"
1279
+ dispatcherType: "auto",
1280
+ keepFinishedRequests: false
1195
1281
  };
1196
1282
 
1197
1283
  // src/hooks/use-cache/use-cache.hooks.ts
1198
- import { useRef as useRef7 } from "react";
1199
- import { useDidUpdate as useDidUpdate5 } from "@better-hooks/lifecycle";
1200
- import { getRequestDispatcher as getRequestDispatcher2, Request as Request3, getRequestKey as getRequestKey3 } from "@hyper-fetch/core";
1201
- 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) => {
1202
1288
  const { cacheKey, client } = request;
1203
1289
  const { cache, loggerManager } = client;
1204
- const logger = useRef7(loggerManager.init("useCache")).current;
1290
+ const logger = useRef6(loggerManager.initialize(client, "useCache")).current;
1205
1291
  const [dispatcher] = getRequestDispatcher2(request);
1206
1292
  const updateKey = JSON.stringify(request.toJSON());
1207
- const [globalConfig] = useConfigProvider();
1208
- 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);
1209
1295
  const [state, actions, { setRenderKey, setCacheData, getIsDataProcessing }] = useTrackedState({
1210
1296
  logger,
1211
1297
  request,
1212
1298
  dispatcher,
1213
- initialData,
1299
+ initialResponse,
1214
1300
  deepCompare,
1215
1301
  dependencyTracking
1216
1302
  });
1217
- const [callbacks, listeners] = useRequestEvents({
1303
+ const [, listeners] = useRequestEvents({
1218
1304
  logger,
1219
1305
  actions,
1220
1306
  request,
@@ -1224,18 +1310,22 @@ var useCache = (request, options = useCacheDefaultOptions) => {
1224
1310
  });
1225
1311
  const { addCacheDataListener, addLifecycleListeners } = listeners;
1226
1312
  const handleMountEvents = () => {
1227
- addCacheDataListener(request);
1228
- addLifecycleListeners(request);
1313
+ const unmountDataListener = addCacheDataListener(request);
1314
+ const unmountLifecycleListener = addLifecycleListeners(request);
1315
+ return () => {
1316
+ unmountDataListener();
1317
+ unmountLifecycleListener();
1318
+ };
1229
1319
  };
1230
- useDidUpdate5(handleMountEvents, [updateKey], true);
1231
- const refetch = (invalidateKey) => {
1232
- if (invalidateKey instanceof Request3) {
1233
- cache.invalidate(getRequestKey3(invalidateKey, true));
1234
- } else if (invalidateKey) {
1235
- cache.invalidate(invalidateKey);
1236
- } else {
1237
- cache.invalidate(cacheKey);
1238
- }
1320
+ useDidUpdate4(
1321
+ () => {
1322
+ return handleMountEvents();
1323
+ },
1324
+ [updateKey],
1325
+ true
1326
+ );
1327
+ const invalidate = (cacheKeys) => {
1328
+ cache.invalidate(cacheKeys != null ? cacheKeys : cacheKey);
1239
1329
  };
1240
1330
  return __spreadProps(__spreadValues({
1241
1331
  get data() {
@@ -1266,47 +1356,47 @@ var useCache = (request, options = useCacheDefaultOptions) => {
1266
1356
  setRenderKey("retries");
1267
1357
  return state.retries;
1268
1358
  },
1269
- get timestamp() {
1270
- setRenderKey("timestamp");
1271
- return state.timestamp;
1359
+ get responseTimestamp() {
1360
+ setRenderKey("responseTimestamp");
1361
+ return state.responseTimestamp;
1272
1362
  },
1273
- onCacheError: callbacks.onError,
1274
- onCacheSuccess: callbacks.onSuccess,
1275
- onCacheChange: callbacks.onFinished
1363
+ get requestTimestamp() {
1364
+ setRenderKey("requestTimestamp");
1365
+ return state.requestTimestamp;
1366
+ }
1276
1367
  }, actions), {
1277
- refetch
1368
+ invalidate
1278
1369
  });
1279
1370
  };
1280
1371
 
1281
1372
  // src/hooks/use-cache/use-cache.constants.ts
1282
1373
  var useCacheDefaultOptions = {
1283
1374
  dependencyTracking: true,
1284
- initialData: null,
1375
+ initialResponse: null,
1285
1376
  deepCompare: true
1286
1377
  };
1287
1378
 
1288
1379
  // src/hooks/use-listener/use-listener.hooks.ts
1289
- import { useRef as useRef8 } from "react";
1290
- 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";
1291
1382
  var useListener = (listener, options) => {
1292
- const [globalConfig] = useConfigProvider();
1383
+ const { config: globalConfig } = useProvider();
1293
1384
  const { dependencyTracking } = __spreadValues(__spreadValues({}, globalConfig.useListener), options);
1294
1385
  const [state, actions, callbacks, { setRenderKey }] = useSocketState(listener.socket, { dependencyTracking });
1295
- const removeListenerRef = useRef8(null);
1296
- const onEventCallback = useRef8(null);
1386
+ const removeListenerRef = useRef7(null);
1387
+ const onEventCallback = useRef7(null);
1297
1388
  const stopListener = () => {
1298
1389
  var _a;
1299
1390
  (_a = removeListenerRef.current) == null ? void 0 : _a.call(removeListenerRef);
1300
1391
  };
1301
1392
  const listen = () => {
1302
1393
  stopListener();
1303
- removeListenerRef.current = listener.listen({
1304
- callback: ({ data, extra }) => {
1305
- var _a;
1306
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, { data, extra });
1307
- actions.setData(data);
1308
- actions.setTimestamp(+new Date());
1309
- }
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());
1310
1400
  });
1311
1401
  };
1312
1402
  const additionalCallbacks = {
@@ -1314,7 +1404,7 @@ var useListener = (listener, options) => {
1314
1404
  onEventCallback.current = callback;
1315
1405
  }
1316
1406
  };
1317
- useDidUpdate6(
1407
+ useDidUpdate5(
1318
1408
  () => {
1319
1409
  listen();
1320
1410
  },
@@ -1329,6 +1419,10 @@ var useListener = (listener, options) => {
1329
1419
  setRenderKey("data");
1330
1420
  return state.data;
1331
1421
  },
1422
+ get extra() {
1423
+ setRenderKey("extra");
1424
+ return state.extra;
1425
+ },
1332
1426
  get connected() {
1333
1427
  setRenderKey("connected");
1334
1428
  return state.connected;
@@ -1347,77 +1441,48 @@ var useListener = (listener, options) => {
1347
1441
  };
1348
1442
 
1349
1443
  // src/hooks/use-emitter/use-emitter.hooks.ts
1350
- import { useRef as useRef9 } from "react";
1444
+ import { useDidUpdate as useDidUpdate6 } from "@better-hooks/lifecycle";
1445
+ import { useRef as useRef8 } from "react";
1351
1446
  var useEmitter = (emitter, options) => {
1352
- const [globalConfig] = useConfigProvider();
1447
+ const { config: globalConfig } = useProvider();
1353
1448
  const { dependencyTracking } = __spreadValues(__spreadValues({}, globalConfig.useEmitter), options);
1354
- const onEventCallback = useRef9(null);
1355
1449
  const [state, actions, callbacks, { setRenderKey }] = useSocketState(emitter.socket, { dependencyTracking });
1356
- const additionalCallbacks = {
1357
- onEvent: (callback) => {
1358
- onEventCallback.current = callback;
1359
- }
1360
- };
1361
- const emit = (emitOptions) => {
1362
- var _a;
1363
- actions.setTimestamp(+new Date());
1364
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, emitter);
1365
- return emitter.emit(emitOptions);
1366
- };
1367
- return __spreadProps(__spreadValues(__spreadValues(__spreadValues({
1368
- get connected() {
1369
- setRenderKey("connected");
1370
- return state.connected;
1371
- },
1372
- get connecting() {
1373
- setRenderKey("connecting");
1374
- return state.connecting;
1375
- },
1376
- get timestamp() {
1377
- setRenderKey("timestamp");
1378
- return state.timestamp;
1379
- }
1380
- }, actions), callbacks), additionalCallbacks), {
1381
- emit,
1382
- reconnect: emitter.socket.reconnect
1383
- });
1384
- };
1385
-
1386
- // src/hooks/use-event-messages/use-event-messages.hooks.ts
1387
- import { useRef as useRef10 } from "react";
1388
- import { useDidUpdate as useDidUpdate7 } from "@better-hooks/lifecycle";
1389
- var useEventMessages = (socket, options) => {
1390
- const [globalConfig] = useConfigProvider();
1391
- const { dependencyTracking = false, filter } = __spreadValues(__spreadValues({}, globalConfig.useEventMessages), options);
1392
- const onEventCallback = useRef10(null);
1393
- const [state, actions, callbacks, { setRenderKey }] = useSocketState(socket, { dependencyTracking });
1394
- useDidUpdate7(
1450
+ const onEventStartCallback = useRef8(null);
1451
+ const onEventErrorCallback = useRef8(null);
1452
+ useDidUpdate6(
1395
1453
  () => {
1396
- const unmountListener = socket.events.onListenerEvent(({ endpoint, data, extra }) => {
1397
- var _a;
1398
- const filterFn = typeof filter === "function" ? () => filter(endpoint, data) : () => filter.includes(endpoint);
1399
- const isFiltered = filter ? filterFn() : false;
1400
- if (!isFiltered) {
1401
- (_a = onEventCallback.current) == null ? void 0 : _a.call(onEventCallback, data, extra);
1402
- actions.setData(data);
1403
- actions.setTimestamp(+new Date());
1404
- }
1405
- });
1406
- 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
+ };
1407
1472
  },
1408
- [socket, filter],
1473
+ [emitter.topic, onEventStartCallback.current, onEventErrorCallback.current],
1409
1474
  true
1410
1475
  );
1411
- const additionalCallbacks = {
1412
- onEvent: (callback) => {
1413
- onEventCallback.current = callback;
1414
- }
1476
+ const emit = (emitOptions) => {
1477
+ return emitter.emit(emitOptions);
1415
1478
  };
1416
- return __spreadValues(__spreadValues(__spreadValues({
1417
- get data() {
1418
- setRenderKey("data");
1419
- return state.data;
1420
- },
1479
+ const onEmit = (callback) => {
1480
+ onEventStartCallback.current = callback;
1481
+ };
1482
+ const onEmitError = (callback) => {
1483
+ onEventErrorCallback.current = callback;
1484
+ };
1485
+ return __spreadProps(__spreadValues(__spreadValues({
1421
1486
  get connected() {
1422
1487
  setRenderKey("connected");
1423
1488
  return state.connected;
@@ -1425,17 +1490,17 @@ var useEventMessages = (socket, options) => {
1425
1490
  get connecting() {
1426
1491
  setRenderKey("connecting");
1427
1492
  return state.connecting;
1428
- },
1429
- get timestamp() {
1430
- setRenderKey("timestamp");
1431
- return state.timestamp;
1432
1493
  }
1433
- }, actions), callbacks), additionalCallbacks);
1494
+ }, actions), callbacks), {
1495
+ onEmit,
1496
+ onEmitError,
1497
+ emit
1498
+ });
1434
1499
  };
1435
1500
 
1436
1501
  // src/hooks/use-app-manager/use-app-manager.hooks.ts
1502
+ import { useDidMount as useDidMount4 } from "@better-hooks/lifecycle";
1437
1503
  import { useState as useState3 } from "react";
1438
- import { useDidMount as useDidMount5 } from "@better-hooks/lifecycle";
1439
1504
  var useAppManager = (client) => {
1440
1505
  const [online, setIsOnline] = useState3(client.appManager.isOnline);
1441
1506
  const [focused, setIsFocused] = useState3(client.appManager.isFocused);
@@ -1457,14 +1522,15 @@ var useAppManager = (client) => {
1457
1522
  const setFocused = (isFocused) => {
1458
1523
  client.appManager.setFocused(isFocused);
1459
1524
  };
1460
- useDidMount5(mountEvents);
1525
+ useDidMount4(mountEvents);
1461
1526
  return { isOnline: online, isFocused: focused, setOnline, setFocused };
1462
1527
  };
1463
1528
  export {
1464
- ConfigProvider,
1529
+ Provider,
1465
1530
  getBounceData,
1466
1531
  getDetailsState,
1467
1532
  getInitialState,
1533
+ getIsInitiallyLoading,
1468
1534
  getRefreshTime,
1469
1535
  getTimestamp,
1470
1536
  getValidCacheData,
@@ -1476,12 +1542,11 @@ export {
1476
1542
  useAppManager,
1477
1543
  useCache,
1478
1544
  useCacheDefaultOptions,
1479
- useConfigProvider,
1480
1545
  useEmitter,
1481
- useEventMessages,
1482
1546
  useFetch,
1483
1547
  useFetchDefaultOptions,
1484
1548
  useListener,
1549
+ useProvider,
1485
1550
  useQueue,
1486
1551
  useQueueDefaultOptions,
1487
1552
  useRequestEvents,
@@ -1490,4 +1555,4 @@ export {
1490
1555
  useSubmitDefaultOptions,
1491
1556
  useTrackedState
1492
1557
  };
1493
- //# sourceMappingURL=index.esm.js.map
1558
+ //# sourceMappingURL=index.js.map