@1money/component-ui 0.0.68 → 0.0.70

package/lib/components/ProTable/useFetchData.js

@@ -0,0 +1,277 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFetchData = useFetchData;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _hooks = require("@1money/hooks");
+var _useAwaitableReload = require("./core/useAwaitableReload");
+var __awaiter = void 0 && (void 0).__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());
+  });
+};
+/**
+ * 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.
+ */
+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 = (0, _hooks.useSafeState)(defaultData !== null && defaultData !== void 0 ? defaultData : []),
+    _useSafeState2 = (0, _slicedToArray2["default"])(_useSafeState, 2),
+    dataSource = _useSafeState2[0],
+    setDataSource = _useSafeState2[1];
+  var _useSafeState3 = (0, _hooks.useSafeState)(false),
+    _useSafeState4 = (0, _slicedToArray2["default"])(_useSafeState3, 2),
+    loading = _useSafeState4[0],
+    setLoadingState = _useSafeState4[1];
+  var _useSafeState5 = (0, _hooks.useSafeState)({
+      current: defaultCurrent,
+      pageSize: defaultPageSize,
+      total: 0
+    }),
+    _useSafeState6 = (0, _slicedToArray2["default"])(_useSafeState5, 2),
+    pageInfo = _useSafeState6[0],
+    setPageInfoState = _useSafeState6[1];
+  var reloadSignal = (0, _useAwaitableReload.useAwaitableReload)();
+  var reqRef = (0, _hooks.useLatest)(request);
+  var callbacks = (0, _hooks.useLatest)({
+    onLoad: onLoad,
+    onLoadingChange: onLoadingChange,
+    onRequestError: onRequestError,
+    postData: postData
+  });
+  var loadingRef = (0, _hooks.useLatest)(loading);
+  var requestIdRef = (0, _react.useRef)(0);
+  var abortRef = (0, _react.useRef)(null);
+  var skipFirstRef = (0, _react.useRef)(manualRequest === true);
+  var prevParamsRef = (0, _react.useRef)(undefined);
+  var debounceTimerRef = (0, _react.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 = (0, _react.useRef)(false);
+  var setLoading = (0, _hooks.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 = (0, _hooks.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 = (0, _hooks.useMemoizedFn)(function (merged, st, ft) {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var _a, _b, _c, _d, _e, _f, req, silent, abort, requestId, result, raw, next, _t;
+      return _regenerator["default"].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);
+  (0, _react.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 = (0, _hooks.useMemoizedFn)(function () {
+    return manual ? Promise.resolve() : reloadSignal.request();
+  });
+  var reset = (0, _hooks.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;
+  (0, _react.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.
+  (0, _react.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/src/components/ProTable/useFetchData.ts","components/ProTable/useFetchData.js"],"names":["_react","require","_hooks","_useAwaitableReload","__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","useFetchData","options","_this","request","manual","manualRequest","debounceTime","postData","polling","params","defaultData","paginated","defaultCurrent","defaultPageSize","searchParams","sort","filter","onLoad","onLoadingChange","onRequestError","_useSafeState","useSafeState","_useSafeState2","_slicedToArray2","dataSource","setDataSource","_useSafeState3","_useSafeState4","loading","setLoadingState","_useSafeState5","current","pageSize","total","_useSafeState6","pageInfo","setPageInfoState","reloadSignal","useAwaitableReload","reqRef","useLatest","callbacks","loadingRef","requestIdRef","useRef","abortRef","skipFirstRef","prevParamsRef","undefined","debounceTimerRef","silentRef","setLoading","useMemoizedFn","_a","_b","call","setPageInfo","info","prev","merged","Object","assign","runRequest","st","ft","_regenerator","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","useEffect","settle","fire","clearTimeout","setTimeout","token","reload","reset","pollingMs","id","setInterval","clearInterval"],"mappings":"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","file":"components/ProTable/useFetchData.js","sourcesContent":[null,"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}"],"sourceRoot":"../../../../../../../../../src"}