@1money/component-ui 0.0.68 → 0.0.69

package/es/components/ProTable/useFetchData.js

@@ -0,0 +1,270 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+import { useEffect, useRef } from 'react';
+import { useLatest, useMemoizedFn, useSafeState } from '@1money/hooks';
+import { useAwaitableReload } from './core/useAwaitableReload';
+/**
+ * Owns the request lifecycle for ProTable: data, loading, and pagination.
+ *
+ * One effect is the single fetch path. It reads its query inputs from the
+ * **render closure** (never a lagging ref), so every state change — search,
+ * sort, filter, params, page — refetches with correct values. An awaitable
+ * reload signal lets imperative callers force the same effect and `await` it.
+ *
+ * `runRequest` aborts the previous in-flight request (`AbortController`, exposed
+ * to `request` as `{ signal }`), tags itself with a request id, and drops stale
+ * or aborted responses.
+ */
+export function useFetchData(options) {
+  var _this = this;
+  var request = options.request,
+    manual = options.manual,
+    manualRequest = options.manualRequest,
+    debounceTime = options.debounceTime,
+    postData = options.postData,
+    polling = options.polling,
+    params = options.params,
+    defaultData = options.defaultData,
+    paginated = options.paginated,
+    defaultCurrent = options.defaultCurrent,
+    defaultPageSize = options.defaultPageSize,
+    searchParams = options.searchParams,
+    sort = options.sort,
+    filter = options.filter,
+    onLoad = options.onLoad,
+    onLoadingChange = options.onLoadingChange,
+    onRequestError = options.onRequestError;
+  var _useSafeState = useSafeState(defaultData !== null && defaultData !== void 0 ? defaultData : []),
+    _useSafeState2 = _slicedToArray(_useSafeState, 2),
+    dataSource = _useSafeState2[0],
+    setDataSource = _useSafeState2[1];
+  var _useSafeState3 = useSafeState(false),
+    _useSafeState4 = _slicedToArray(_useSafeState3, 2),
+    loading = _useSafeState4[0],
+    setLoadingState = _useSafeState4[1];
+  var _useSafeState5 = useSafeState({
+      current: defaultCurrent,
+      pageSize: defaultPageSize,
+      total: 0
+    }),
+    _useSafeState6 = _slicedToArray(_useSafeState5, 2),
+    pageInfo = _useSafeState6[0],
+    setPageInfoState = _useSafeState6[1];
+  var reloadSignal = useAwaitableReload();
+  var reqRef = useLatest(request);
+  var callbacks = useLatest({
+    onLoad: onLoad,
+    onLoadingChange: onLoadingChange,
+    onRequestError: onRequestError,
+    postData: postData
+  });
+  var loadingRef = useLatest(loading);
+  var requestIdRef = useRef(0);
+  var abortRef = useRef(null);
+  var skipFirstRef = useRef(manualRequest === true);
+  var prevParamsRef = useRef(undefined);
+  var debounceTimerRef = useRef(undefined);
+  // Set right before a polling-triggered refetch so it can refresh silently
+  // (without flashing the main loading overlay). Consumed at the start of runRequest.
+  var silentRef = useRef(false);
+  var setLoading = useMemoizedFn(function (next) {
+    var _a, _b;
+    setLoadingState(next);
+    (_b = (_a = callbacks.current).onLoadingChange) === null || _b === void 0 ? void 0 : _b.call(_a, next);
+  });
+  var setPageInfo = useMemoizedFn(function (info) {
+    setPageInfoState(function (prev) {
+      var merged = Object.assign(Object.assign({}, prev), info);
+      if (merged.current === prev.current && merged.pageSize === prev.pageSize && merged.total === prev.total) {
+        return prev;
+      }
+      return merged;
+    });
+  });
+  // The single network entry point: abort the previous request, then apply data
+  // while guarding against stale / aborted responses.
+  var runRequest = useMemoizedFn(function (merged, st, ft) {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var _a, _b, _c, _d, _e, _f, req, silent, abort, requestId, result, raw, next, _t;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            req = reqRef.current;
+            if (req) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return");
+          case 1:
+            // A polling refetch refreshes silently — no loading overlay flash.
+            silent = silentRef.current;
+            silentRef.current = false;
+            (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+            abort = new AbortController();
+            abortRef.current = abort;
+            requestId = ++requestIdRef.current;
+            if (!silent) setLoading(true);
+            _context.prev = 2;
+            _context.next = 3;
+            return req(merged, st, ft, {
+              signal: abort.signal
+            });
+          case 3:
+            result = _context.sent;
+            if (!(abort.signal.aborted || requestId !== requestIdRef.current)) {
+              _context.next = 4;
+              break;
+            }
+            return _context.abrupt("return");
+          case 4:
+            if (!(result.success === false)) {
+              _context.next = 5;
+              break;
+            }
+            return _context.abrupt("return");
+          case 5:
+            raw = (_b = result.data) !== null && _b !== void 0 ? _b : [];
+            next = callbacks.current.postData ? callbacks.current.postData(raw) : raw;
+            setDataSource(next);
+            setPageInfoState(function (prev) {
+              var _a;
+              return Object.assign(Object.assign({}, prev), {
+                total: (_a = result.total) !== null && _a !== void 0 ? _a : next.length
+              });
+            });
+            (_d = (_c = callbacks.current).onLoad) === null || _d === void 0 ? void 0 : _d.call(_c, next);
+            _context.next = 8;
+            break;
+          case 6:
+            _context.prev = 6;
+            _t = _context["catch"](2);
+            if (!(abort.signal.aborted || requestId !== requestIdRef.current)) {
+              _context.next = 7;
+              break;
+            }
+            return _context.abrupt("return");
+          case 7:
+            (_f = (_e = callbacks.current).onRequestError) === null || _f === void 0 ? void 0 : _f.call(_e, _t);
+          case 8:
+            _context.prev = 8;
+            if (!silent && requestId === requestIdRef.current) setLoading(false);
+            return _context.finish(8);
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[2, 6, 8, 9]]);
+    }));
+  });
+  // Build the request params from the current render closure.
+  var buildMerged = function buildMerged() {
+    return Object.assign(Object.assign(Object.assign({}, params !== null && params !== void 0 ? params : {}), searchParams), paginated ? {
+      current: pageInfo.current,
+      pageSize: pageInfo.pageSize
+    } : {});
+  };
+  // Only `params` (a consumer-owned prop, often an inline object) needs value
+  // comparison; the rest are stable internal state and compare by reference.
+  var paramsKey = JSON.stringify(params !== null && params !== void 0 ? params : null);
+  useEffect(function () {
+    if (manual) {
+      reloadSignal.settle();
+      return;
+    }
+    // manualRequest: swallow only the first (mount) trigger.
+    if (skipFirstRef.current) {
+      skipFirstRef.current = false;
+      prevParamsRef.current = paramsKey;
+      reloadSignal.settle();
+      return;
+    }
+    // A `params` change resets to page 1 first; the page change re-runs this
+    // effect, where the actual fetch happens (so it never double-fetches).
+    if (prevParamsRef.current !== paramsKey && pageInfo.current !== defaultCurrent) {
+      prevParamsRef.current = paramsKey;
+      setPageInfo({
+        current: defaultCurrent
+      });
+      return;
+    }
+    prevParamsRef.current = paramsKey;
+    var fire = function fire() {
+      return runRequest(buildMerged(), sort, filter)["finally"](reloadSignal.settle);
+    };
+    if (debounceTime && debounceTime > 0) {
+      if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+      debounceTimerRef.current = setTimeout(fire, debounceTime);
+      return function () {
+        if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+      };
+    }
+    void fire();
+  }, [paramsKey, searchParams, sort, filter, pageInfo.current, pageInfo.pageSize, reloadSignal.token, manual]);
+  var reload = useMemoizedFn(function () {
+    return manual ? Promise.resolve() : reloadSignal.request();
+  });
+  var reset = useMemoizedFn(function () {
+    setPageInfoState(function (prev) {
+      return Object.assign(Object.assign({}, prev), {
+        current: defaultCurrent,
+        pageSize: defaultPageSize
+      });
+    });
+  });
+  // Polling: re-trigger on an interval, skipping ticks while a request is in flight.
+  var pollingMs = typeof polling === 'function' ? polling(dataSource) : polling;
+  useEffect(function () {
+    if (manual || !pollingMs || pollingMs <= 0) return;
+    var id = setInterval(function () {
+      if (loadingRef.current) return;
+      silentRef.current = true;
+      void reloadSignal.request();
+    }, pollingMs);
+    return function () {
+      return clearInterval(id);
+    };
+  }, [pollingMs, manual]);
+  // Abort any in-flight request on unmount.
+  useEffect(function () {
+    return function () {
+      var _a;
+      return (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+    };
+  }, []);
+  return {
+    dataSource: dataSource,
+    loading: loading,
+    pageInfo: pageInfo,
+    setPageInfo: setPageInfo,
+    reload: reload,
+    reset: reset
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProTable/useFetchData.js","components/src/components/ProTable/useFetchData.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","useEffect","useRef","useLatest","useMemoizedFn","useSafeState","useAwaitableReload","useFetchData","options","_this","request","manual","manualRequest","debounceTime","postData","polling","params","defaultData","paginated","defaultCurrent","defaultPageSize","searchParams","sort","filter","onLoad","onLoadingChange","onRequestError","_useSafeState","_useSafeState2","_slicedToArray","dataSource","setDataSource","_useSafeState3","_useSafeState4","loading","setLoadingState","_useSafeState5","current","pageSize","total","_useSafeState6","pageInfo","setPageInfoState","reloadSignal","reqRef","callbacks","loadingRef","requestIdRef","abortRef","skipFirstRef","prevParamsRef","undefined","debounceTimerRef","silentRef","setLoading","_a","_b","call","setPageInfo","info","prev","merged","Object","assign","runRequest","st","ft","_regeneratorRuntime","mark","_callee","_c","_d","_e","_f","req","silent","abort","requestId","raw","_t","wrap","_context","abrupt","AbortController","signal","sent","aborted","success","data","length","finish","stop","buildMerged","paramsKey","JSON","stringify","settle","fire","clearTimeout","setTimeout","token","reload","reset","pollingMs","id","setInterval","clearInterval"],"mappings":"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","file":"components/ProTable/useFetchData.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { useEffect, useRef } from 'react';\nimport { useLatest, useMemoizedFn, useSafeState } from '@1money/hooks';\nimport { useAwaitableReload } from './core/useAwaitableReload';\n/**\n * Owns the request lifecycle for ProTable: data, loading, and pagination.\n *\n * One effect is the single fetch path. It reads its query inputs from the\n * **render closure** (never a lagging ref), so every state change — search,\n * sort, filter, params, page — refetches with correct values. An awaitable\n * reload signal lets imperative callers force the same effect and `await` it.\n *\n * `runRequest` aborts the previous in-flight request (`AbortController`, exposed\n * to `request` as `{ signal }`), tags itself with a request id, and drops stale\n * or aborted responses.\n */\nexport function useFetchData(options) {\n    const { request, manual, manualRequest, debounceTime, postData, polling, params, defaultData, paginated, defaultCurrent, defaultPageSize, searchParams, sort, filter, onLoad, onLoadingChange, onRequestError, } = options;\n    const [dataSource, setDataSource] = useSafeState(defaultData !== null && defaultData !== void 0 ? defaultData : []);\n    const [loading, setLoadingState] = useSafeState(false);\n    const [pageInfo, setPageInfoState] = useSafeState({\n        current: defaultCurrent,\n        pageSize: defaultPageSize,\n        total: 0,\n    });\n    const reloadSignal = useAwaitableReload();\n    const reqRef = useLatest(request);\n    const callbacks = useLatest({ onLoad, onLoadingChange, onRequestError, postData });\n    const loadingRef = useLatest(loading);\n    const requestIdRef = useRef(0);\n    const abortRef = useRef(null);\n    const skipFirstRef = useRef(manualRequest === true);\n    const prevParamsRef = useRef(undefined);\n    const debounceTimerRef = useRef(undefined);\n    // Set right before a polling-triggered refetch so it can refresh silently\n    // (without flashing the main loading overlay). Consumed at the start of runRequest.\n    const silentRef = useRef(false);\n    const setLoading = useMemoizedFn((next) => {\n        var _a, _b;\n        setLoadingState(next);\n        (_b = (_a = callbacks.current).onLoadingChange) === null || _b === void 0 ? void 0 : _b.call(_a, next);\n    });\n    const setPageInfo = useMemoizedFn((info) => {\n        setPageInfoState((prev) => {\n            const merged = Object.assign(Object.assign({}, prev), info);\n            if (merged.current === prev.current && merged.pageSize === prev.pageSize && merged.total === prev.total) {\n                return prev;\n            }\n            return merged;\n        });\n    });\n    // The single network entry point: abort the previous request, then apply data\n    // while guarding against stale / aborted responses.\n    const runRequest = useMemoizedFn((merged, st, ft) => __awaiter(this, void 0, void 0, function* () {\n        var _a, _b, _c, _d, _e, _f;\n        const req = reqRef.current;\n        if (!req)\n            return;\n        // A polling refetch refreshes silently — no loading overlay flash.\n        const silent = silentRef.current;\n        silentRef.current = false;\n        (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();\n        const abort = new AbortController();\n        abortRef.current = abort;\n        const requestId = ++requestIdRef.current;\n        if (!silent)\n            setLoading(true);\n        try {\n            const result = yield req(merged, st, ft, { signal: abort.signal });\n            if (abort.signal.aborted || requestId !== requestIdRef.current)\n                return;\n            if (result.success === false)\n                return;\n            const raw = (_b = result.data) !== null && _b !== void 0 ? _b : [];\n            const next = callbacks.current.postData ? callbacks.current.postData(raw) : raw;\n            setDataSource(next);\n            setPageInfoState((prev) => { var _a; return (Object.assign(Object.assign({}, prev), { total: (_a = result.total) !== null && _a !== void 0 ? _a : next.length })); });\n            (_d = (_c = callbacks.current).onLoad) === null || _d === void 0 ? void 0 : _d.call(_c, next);\n        }\n        catch (error) {\n            if (abort.signal.aborted || requestId !== requestIdRef.current)\n                return;\n            (_f = (_e = callbacks.current).onRequestError) === null || _f === void 0 ? void 0 : _f.call(_e, error);\n        }\n        finally {\n            if (!silent && requestId === requestIdRef.current)\n                setLoading(false);\n        }\n    }));\n    // Build the request params from the current render closure.\n    const buildMerged = () => (Object.assign(Object.assign(Object.assign({}, (params !== null && params !== void 0 ? params : {})), searchParams), (paginated ? { current: pageInfo.current, pageSize: pageInfo.pageSize } : {})));\n    // Only `params` (a consumer-owned prop, often an inline object) needs value\n    // comparison; the rest are stable internal state and compare by reference.\n    const paramsKey = JSON.stringify(params !== null && params !== void 0 ? params : null);\n    useEffect(() => {\n        if (manual) {\n            reloadSignal.settle();\n            return;\n        }\n        // manualRequest: swallow only the first (mount) trigger.\n        if (skipFirstRef.current) {\n            skipFirstRef.current = false;\n            prevParamsRef.current = paramsKey;\n            reloadSignal.settle();\n            return;\n        }\n        // A `params` change resets to page 1 first; the page change re-runs this\n        // effect, where the actual fetch happens (so it never double-fetches).\n        if (prevParamsRef.current !== paramsKey && pageInfo.current !== defaultCurrent) {\n            prevParamsRef.current = paramsKey;\n            setPageInfo({ current: defaultCurrent });\n            return;\n        }\n        prevParamsRef.current = paramsKey;\n        const fire = () => runRequest(buildMerged(), sort, filter).finally(reloadSignal.settle);\n        if (debounceTime && debounceTime > 0) {\n            if (debounceTimerRef.current)\n                clearTimeout(debounceTimerRef.current);\n            debounceTimerRef.current = setTimeout(fire, debounceTime);\n            return () => {\n                if (debounceTimerRef.current)\n                    clearTimeout(debounceTimerRef.current);\n            };\n        }\n        void fire();\n    }, [paramsKey, searchParams, sort, filter, pageInfo.current, pageInfo.pageSize, reloadSignal.token, manual]);\n    const reload = useMemoizedFn(() => (manual ? Promise.resolve() : reloadSignal.request()));\n    const reset = useMemoizedFn(() => {\n        setPageInfoState((prev) => (Object.assign(Object.assign({}, prev), { current: defaultCurrent, pageSize: defaultPageSize })));\n    });\n    // Polling: re-trigger on an interval, skipping ticks while a request is in flight.\n    const pollingMs = typeof polling === 'function' ? polling(dataSource) : polling;\n    useEffect(() => {\n        if (manual || !pollingMs || pollingMs <= 0)\n            return;\n        const id = setInterval(() => {\n            if (loadingRef.current)\n                return;\n            silentRef.current = true;\n            void reloadSignal.request();\n        }, pollingMs);\n        return () => clearInterval(id);\n    }, [pollingMs, manual]);\n    // Abort any in-flight request on unmount.\n    useEffect(() => () => { var _a; return (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort(); }, []);\n    return { dataSource, loading, pageInfo, setPageInfo, reload, reset };\n}",null],"sourceRoot":"../../../../../../../../../src"}