Update from Vibe Studio

node_modules/@ant-design/pro-utils/lib/hooks/useDebounceFn/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 一个去抖的 hook，传入一个 function，返回一个去抖后的 function
+ * @param  {(...args:T) => Promise<any>} fn
+ * @param  {number} wait?
+ */
+export declare function useDebounceFn<T extends any[], U = any>(fn: (...args: T) => Promise<any>, wait?: number): {
+    run: (...args: any) => Promise<U | undefined>;
+    cancel: () => void;
+};

node_modules/@ant-design/pro-utils/lib/hooks/useDebounceFn/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDebounceFn = useDebounceFn;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _react = require("react");
+var _useRefFunction = require("../useRefFunction");
+/**
+ * 一个去抖的 hook，传入一个 function，返回一个去抖后的 function
+ * @param  {(...args:T) => Promise<any>} fn
+ * @param  {number} wait?
+ */
+function useDebounceFn(fn, wait) {
+  var callback = (0, _useRefFunction.useRefFunction)(fn);
+  var timer = (0, _react.useRef)();
+  var cancel = (0, _react.useCallback)(function () {
+    if (timer.current) {
+      clearTimeout(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  var run = (0, _react.useCallback)( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2() {
+    var _len,
+      args,
+      _key,
+      _args2 = arguments;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          for (_len = _args2.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = _args2[_key];
+          }
+          if (!(wait === 0 || wait === undefined)) {
+            _context2.next = 3;
+            break;
+          }
+          return _context2.abrupt("return", callback.apply(void 0, args));
+        case 3:
+          cancel();
+          return _context2.abrupt("return", new Promise(function (resolve) {
+            timer.current = setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
+              return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.t0 = resolve;
+                    _context.next = 3;
+                    return callback.apply(void 0, args);
+                  case 3:
+                    _context.t1 = _context.sent;
+                    (0, _context.t0)(_context.t1);
+                    return _context.abrupt("return");
+                  case 6:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            })), wait);
+          }));
+        case 5:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })), [callback, cancel, wait]);
+  (0, _react.useEffect)(function () {
+    return cancel;
+  }, [cancel]);
+  return {
+    run: run,
+    cancel: cancel
+  };
+}

node_modules/@ant-design/pro-utils/lib/hooks/useDebounceValue/index.d.ts

@@ -0,0 +1,9 @@
+import type { DependencyList } from 'react';
+/**
+ * 一个去抖的setState 减少更新的频率
+ * @param  {T} value
+ * @param  {number=100} delay
+ * @param  {DependencyList} deps?
+ * @returns T
+ */
+export declare function useDebounceValue<T>(value: T, delay?: number, deps?: DependencyList): T;

node_modules/@ant-design/pro-utils/lib/hooks/useDebounceValue/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDebounceValue = useDebounceValue;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _useLatest = require("../useLatest");
+/**
+ * 一个去抖的setState 减少更新的频率
+ * @param  {T} value
+ * @param  {number=100} delay
+ * @param  {DependencyList} deps?
+ * @returns T
+ */
+function useDebounceValue(value) {
+  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+  var deps = arguments.length > 2 ? arguments[2] : undefined;
+  var _useState = (0, _react.useState)(value),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    debouncedValue = _useState2[0],
+    setDebouncedValue = _useState2[1];
+  var valueRef = (0, _useLatest.useLatest)(value);
+  (0, _react.useEffect)(function () {
+    var handler = setTimeout(function () {
+      setDebouncedValue(valueRef.current);
+    }, delay);
+    return function () {
+      return clearTimeout(handler);
+    };
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  deps ? [delay].concat((0, _toConsumableArray2.default)(deps)) : undefined);
+  return debouncedValue;
+}

node_modules/@ant-design/pro-utils/lib/hooks/useDeepCompareEffect/index.d.ts

@@ -0,0 +1,5 @@
+import type { DependencyList } from 'react';
+export declare const isDeepEqual: (a: any, b: any, ignoreKeys?: string[]) => boolean;
+export declare function useDeepCompareMemoize(value: any, ignoreKeys?: any): undefined;
+export declare function useDeepCompareEffect(effect: React.EffectCallback, dependencies: DependencyList, ignoreKeys?: string[]): void;
+export declare function useDeepCompareEffectDebounce(effect: React.EffectCallback, dependencies: DependencyList, ignoreKeys?: string[], waitTime?: number): void;

node_modules/@ant-design/pro-utils/lib/hooks/useDeepCompareEffect/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDeepEqual = void 0;
+exports.useDeepCompareEffect = useDeepCompareEffect;
+exports.useDeepCompareEffectDebounce = useDeepCompareEffectDebounce;
+exports.useDeepCompareMemoize = useDeepCompareMemoize;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _react = require("react");
+var _isDeepEqualReact = require("../../isDeepEqualReact");
+var _useDebounceFn = require("../useDebounceFn");
+var isDeepEqual = exports.isDeepEqual = function isDeepEqual(a, b, ignoreKeys) {
+  return (0, _isDeepEqualReact.isDeepEqualReact)(a, b, ignoreKeys);
+};
+function useDeepCompareMemoize(value, ignoreKeys) {
+  var ref = (0, _react.useRef)();
+  // it can be done by using useMemo as well
+  // but useRef is rather cleaner and easier
+  if (!isDeepEqual(value, ref.current, ignoreKeys)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+function useDeepCompareEffect(effect, dependencies, ignoreKeys) {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  (0, _react.useEffect)(effect, useDeepCompareMemoize(dependencies || [], ignoreKeys));
+}
+function useDeepCompareEffectDebounce(effect, dependencies, ignoreKeys, waitTime) {
+  var effectDn = (0, _useDebounceFn.useDebounceFn)( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          effect();
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })), waitTime || 16);
+  (0, _react.useEffect)(function () {
+    effectDn.run();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, useDeepCompareMemoize(dependencies || [], ignoreKeys));
+}

node_modules/@ant-design/pro-utils/lib/hooks/useDeepCompareMemo/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * `useDeepCompareMemo` will only recompute the memoized value when one of the
+ * `deps` has changed.
+ *
+ * Usage note: only use this if `deps` are objects or arrays that contain
+ * objects. Otherwise you should just use React.useMemo.
+ *
+ */
+declare function useDeepCompareMemo<T>(factory: () => T, dependencies: React.DependencyList): T;
+export default useDeepCompareMemo;

node_modules/@ant-design/pro-utils/lib/hooks/useDeepCompareMemo/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _useDeepCompareEffect = require("../useDeepCompareEffect");
+/**
+ * `useDeepCompareMemo` will only recompute the memoized value when one of the
+ * `deps` has changed.
+ *
+ * Usage note: only use this if `deps` are objects or arrays that contain
+ * objects. Otherwise you should just use React.useMemo.
+ *
+ */
+function useDeepCompareMemo(factory, dependencies) {
+  return _react.default.useMemo(factory, (0, _useDeepCompareEffect.useDeepCompareMemoize)(dependencies));
+}
+var _default = exports.default = useDeepCompareMemo;

node_modules/@ant-design/pro-utils/lib/hooks/useDocumentTitle/index.d.ts

@@ -0,0 +1,5 @@
+export declare function useDocumentTitle(titleInfo: {
+    title: string;
+    id: string;
+    pageName: string;
+}, appDefaultTitle: string | false): void;

node_modules/@ant-design/pro-utils/lib/hooks/useDocumentTitle/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDocumentTitle = useDocumentTitle;
+var _react = require("react");
+var _isBrowser = require("../../isBrowser");
+function useDocumentTitle(titleInfo, appDefaultTitle) {
+  var titleText = typeof titleInfo.pageName === 'string' ? titleInfo.title : appDefaultTitle;
+  (0, _react.useEffect)(function () {
+    if ((0, _isBrowser.isBrowser)() && titleText) {
+      document.title = titleText;
+    }
+  }, [titleInfo.title, titleText]);
+}

node_modules/@ant-design/pro-utils/lib/hooks/useFetchData/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export type ProRequestData<T, U = Record<string, any>> = (params: U, props: any) => Promise<T>;
+export declare function useFetchData<T, U = Record<string, any>>(props: {
+    proFieldKey?: React.Key;
+    params?: U;
+    request?: ProRequestData<T, U>;
+}): [T | undefined];

node_modules/@ant-design/pro-utils/lib/hooks/useFetchData/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFetchData = useFetchData;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _swr = _interopRequireDefault(require("swr"));
+var testId = 0;
+function useFetchData(props) {
+  var abortRef = (0, _react.useRef)(null);
+  /** Key 是用来缓存请求的，如果不在是有问题 */
+  var _useState = (0, _react.useState)(function () {
+      if (props.proFieldKey) {
+        return props.proFieldKey.toString();
+      }
+      testId += 1;
+      return testId.toString();
+    }),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 1),
+    cacheKey = _useState2[0];
+  var proFieldKeyRef = (0, _react.useRef)(cacheKey);
+  var fetchData = /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
+      var _abortRef$current, _props$request;
+      var abort, loadData;
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            (_abortRef$current = abortRef.current) === null || _abortRef$current === void 0 || _abortRef$current.abort();
+            abort = new AbortController();
+            abortRef.current = abort;
+            _context.next = 5;
+            return Promise.race([(_props$request = props.request) === null || _props$request === void 0 ? void 0 : _props$request.call(props, props.params, props), new Promise(function (_, reject) {
+              var _abortRef$current2;
+              (_abortRef$current2 = abortRef.current) === null || _abortRef$current2 === void 0 || (_abortRef$current2 = _abortRef$current2.signal) === null || _abortRef$current2 === void 0 || _abortRef$current2.addEventListener('abort', function () {
+                reject(new Error('aborted'));
+              });
+            })]);
+          case 5:
+            loadData = _context.sent;
+            return _context.abrupt("return", loadData);
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function fetchData() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  (0, _react.useEffect)(function () {
+    return function () {
+      testId += 1;
+    };
+  }, []);
+  var _useSWR = (0, _swr.default)([proFieldKeyRef.current, props.params], fetchData, {
+      revalidateOnFocus: false,
+      shouldRetryOnError: false,
+      revalidateOnReconnect: false
+    }),
+    data = _useSWR.data,
+    error = _useSWR.error;
+  return [data || error];
+}

node_modules/@ant-design/pro-utils/lib/hooks/useForceRender/index.d.ts

@@ -0,0 +1 @@
+export default function useForceRender(): () => void;

node_modules/@ant-design/pro-utils/lib/hooks/useForceRender/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useForceRender;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+function useForceRender() {
+  var _useState = (0, _react.useState)(true),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    setValue = _useState2[1];
+  var updateValue = (0, _react.useCallback)(function () {
+    return setValue(function (oldValue) {
+      return !oldValue;
+    });
+  }, []);
+  return updateValue;
+}

node_modules/@ant-design/pro-utils/lib/hooks/useLatest/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://github.com/streamich/react-use/blob/master/docs/useLatest.md
+ */
+export declare const useLatest: <T>(value: T) => {
+    readonly current: T;
+};

node_modules/@ant-design/pro-utils/lib/hooks/useLatest/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLatest = void 0;
+var _react = require("react");
+/**
+ * @see https://github.com/streamich/react-use/blob/master/docs/useLatest.md
+ */
+var useLatest = exports.useLatest = function useLatest(value) {
+  var ref = (0, _react.useRef)(value);
+  ref.current = value;
+  return ref;
+};

node_modules/@ant-design/pro-utils/lib/hooks/usePrevious/index.d.ts

@@ -0,0 +1 @@
+export declare const usePrevious: <T>(state: T) => T | undefined;

node_modules/@ant-design/pro-utils/lib/hooks/usePrevious/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePrevious = void 0;
+var _react = require("react");
+var usePrevious = exports.usePrevious = function usePrevious(state) {
+  var ref = (0, _react.useRef)();
+  (0, _react.useEffect)(function () {
+    ref.current = state;
+  });
+  return ref.current;
+};

node_modules/@ant-design/pro-utils/lib/hooks/useReactiveRef/index.d.ts

@@ -0,0 +1,4 @@
+import type { MutableRefObject, RefObject } from 'react';
+export declare function useReactiveRef<T>(initialValue: T): MutableRefObject<T>;
+export declare function useReactiveRef<T>(initialValue: T | null): RefObject<T>;
+export declare function useReactiveRef<T = undefined>(): MutableRefObject<T | undefined>;

node_modules/@ant-design/pro-utils/lib/hooks/useReactiveRef/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useReactiveRef = useReactiveRef;
+var _useForceRender = _interopRequireDefault(require("../useForceRender"));
+var _useRefCallback = require("../useRefCallback");
+function useReactiveRef(initialValue) {
+  var forceRender = (0, _useForceRender.default)();
+  var ref = (0, _useRefCallback.useRefCallback)(forceRender, initialValue);
+  return ref;
+}

node_modules/@ant-design/pro-utils/lib/hooks/useRefCallback/index.d.ts

@@ -0,0 +1,6 @@
+import type { MutableRefObject, RefObject } from 'react';
+type Callback<T> = (currentRef: T) => void;
+export declare function useRefCallback<T>(callback: Callback<MutableRefObject<T>>, initialValue: T): MutableRefObject<T>;
+export declare function useRefCallback<T>(callback: Callback<RefObject<T>>, initialValue: T | null): RefObject<T>;
+export declare function useRefCallback<T = undefined>(callback: Callback<MutableRefObject<T | undefined>>): MutableRefObject<T | undefined>;
+export {};

node_modules/@ant-design/pro-utils/lib/hooks/useRefCallback/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRefCallback = useRefCallback;
+var _react = require("react");
+function useRefCallback(callback, initialValue) {
+  var ref = (0, _react.useMemo)(function () {
+    var defaultValue = {
+      current: initialValue
+    };
+    return new Proxy(defaultValue, {
+      set: function set(target, prop, newValue) {
+        if (!Object.is(target[prop], newValue)) {
+          target[prop] = newValue;
+          callback(ref);
+        }
+        return true;
+      }
+    });
+  }, []);
+  return ref;
+}

node_modules/@ant-design/pro-utils/lib/hooks/useRefFunction/index.d.ts

@@ -0,0 +1,2 @@
+declare const useRefFunction: <T extends (...args: any) => any>(reFunction: T) => (...rest: Parameters<T>) => ReturnType<T>;
+export { useRefFunction };

node_modules/@ant-design/pro-utils/lib/hooks/useRefFunction/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRefFunction = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _react = require("react");
+var useRefFunction = exports.useRefFunction = function useRefFunction(reFunction) {
+  var ref = (0, _react.useRef)(null);
+  ref.current = reFunction;
+  return (0, _react.useCallback)(function () {
+    var _ref$current;
+    for (var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++) {
+      rest[_key] = arguments[_key];
+    }
+    return (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.call.apply(_ref$current, [ref].concat((0, _toConsumableArray2.default)(rest)));
+  }, []);
+};