@wzyjs/hooks 0.2.27 → 0.2.37

package/dist/base/useOnceEffect.js

@@ -0,0 +1,24 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnceEffect = void 0;
+var react_1 = require("react");
+var useOnceEffect = function (effect, deps) {
+    var _a = (0, react_1.useState)(false), hasRun = _a[0], setHasRun = _a[1];
+    (0, react_1.useEffect)(function () {
+        if (hasRun) {
+            return;
+        }
+        var res = effect();
+        setHasRun(res);
+    }, __spreadArray([hasRun, effect], deps, true));
+};
+exports.useOnceEffect = useOnceEffect;

package/dist/base/useVisibleInfo.d.ts

@@ -0,0 +1,5 @@
+export declare const useVisibleInfo: (v: boolean, i: any) => (boolean | any[] | {
+    setTrue: () => void;
+    setFalse: () => void;
+    toggle: () => void;
+})[];

package/dist/base/useVisibleInfo.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVisibleInfo = void 0;
+var react_1 = require("react");
+// visible和info的集合体
+var useVisibleInfo = function (v, i) {
+    if (v === void 0) { v = false; }
+    var _a = (0, react_1.useState)(v), visible = _a[0], setVisible = _a[1];
+    var _b = (0, react_1.useState)(i), info = _b[0], setInfo = _b[1];
+    return [
+        visible,
+        {
+            setTrue: function () { return setVisible(true); },
+            setFalse: function () { return setVisible(false); },
+            toggle: function () { return setVisible(!visible); },
+        },
+        [
+            info,
+            setInfo,
+        ],
+    ];
+};
+exports.useVisibleInfo = useVisibleInfo;

package/dist/dom/useElementScrollVisible.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useElementScrollVisible = void 0;
+var react_1 = require("react");
+// 判断某元素滚动时，指定元素是否显示
+var useElementScrollVisible = function (scroll, target) {
+    var $scroll = document.querySelector(scroll) || {};
+    var $scrollRect = $scroll.getBoundingClientRect();
+    var _a = (0, react_1.useState)(false), visible = _a[0], setVisible = _a[1];
+    var _b = (0, react_1.useState)(''), direction = _b[0], setDirection = _b[1];
+    var _c = (0, react_1.useState)(''), rect = _c[0], setRect = _c[1];
+    (0, react_1.useEffect)(function () {
+        var fn = function () {
+            var $target = document.querySelector(target) || {};
+            var rect = $target.getBoundingClientRect();
+            setRect(rect);
+            if (rect.bottom < $scrollRect.top) {
+                setDirection('top');
+                setVisible(false);
+            }
+            else if (rect.top > $scrollRect.bottom) {
+                setDirection('bottom');
+                setVisible(false);
+            }
+            else {
+                setDirection('show');
+                setVisible(true);
+            }
+        };
+        fn();
+        $scroll.addEventListener('scroll', fn);
+        return function () { return $scroll.removeEventListener('scroll', fn); };
+    }, []);
+    return {
+        visible: visible,
+        direction: direction,
+        rect: rect,
+    };
+};
+exports.useElementScrollVisible = useElementScrollVisible;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from 'ahooks';
+export { default as useUrlState } from '@ahooksjs/use-url-state';
+export { useCopyToClipboard, useCookie, useUpdate } from 'react-use';
+export * from './base/useEffectValue';
+export * from './base/useVisibleInfo';
+export * from './base/useClick';
+export * from './antd/useForm';
+export * from './antd/usePaginationState';
+export * from './antd/useHideFooter';
+export * from './antd/useHovered';
+export * from './antd/useModalFooter';
+export * from './antd/useImperativeHandleForm';
+export * from './dom/useElementScrollVisible';

package/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUpdate = exports.useCookie = exports.useCopyToClipboard = exports.useUrlState = void 0;
+__exportStar(require("ahooks"), exports);
+var use_url_state_1 = require("@ahooksjs/use-url-state");
+Object.defineProperty(exports, "useUrlState", { enumerable: true, get: function () { return __importDefault(use_url_state_1).default; } });
+var react_use_1 = require("react-use");
+Object.defineProperty(exports, "useCopyToClipboard", { enumerable: true, get: function () { return react_use_1.useCopyToClipboard; } });
+Object.defineProperty(exports, "useCookie", { enumerable: true, get: function () { return react_use_1.useCookie; } });
+Object.defineProperty(exports, "useUpdate", { enumerable: true, get: function () { return react_use_1.useUpdate; } });
+__exportStar(require("./base/useEffectValue"), exports);
+__exportStar(require("./base/useVisibleInfo"), exports);
+__exportStar(require("./base/useClick"), exports);
+__exportStar(require("./antd/useForm"), exports);
+__exportStar(require("./antd/usePaginationState"), exports);
+__exportStar(require("./antd/useHideFooter"), exports);
+__exportStar(require("./antd/useHovered"), exports);
+__exportStar(require("./antd/useModalFooter"), exports);
+__exportStar(require("./antd/useImperativeHandleForm"), exports);
+__exportStar(require("./dom/useElementScrollVisible"), exports);
+// export * from './other/useSetting'
+//
+// export * from './useRequestPro'
+// export * from './useDateRange'
+// export * from './useOptions'

package/dist/other/useCRUD.d.ts

@@ -0,0 +1,63 @@
+export interface ApiResult<D = any> {
+    status?: string;
+    message?: string;
+    success?: boolean;
+    data?: D;
+    meta?: {
+        total_count?: number;
+        filter_count?: number;
+    };
+}
+export declare enum CRUDAction {
+    Info = "info",
+    List = "list",
+    Create = "create",
+    Update = "update",
+    Delete = "delete"
+}
+type InfoAPI<I> = (id: string) => Promise<ApiResult<I>>;
+type ListAPI<I> = (params?: any) => Promise<ApiResult<I[]>>;
+type CreateAPI<I> = (data: any) => Promise<ApiResult<I>>;
+type UpdateAPI<I> = (id: string, data: any) => Promise<ApiResult<I>>;
+type DeleteAPI<I> = (id: string) => Promise<ApiResult<I>>;
+interface Apis<I> {
+    [CRUDAction.Info]?: InfoAPI<I>;
+    [CRUDAction.List]?: ListAPI<I>;
+    [CRUDAction.Create]?: CreateAPI<I>;
+    [CRUDAction.Update]?: UpdateAPI<I>;
+    [CRUDAction.Delete]?: DeleteAPI<I>;
+}
+interface AutoRefreshList {
+    [CRUDAction.Info]?: boolean;
+    [CRUDAction.List]?: boolean;
+    [CRUDAction.Create]?: boolean;
+    [CRUDAction.Update]?: boolean;
+    [CRUDAction.Delete]?: boolean;
+}
+interface CRUDOptions<I> {
+    id?: string;
+    apis: Apis<I>;
+    autoRefreshList?: boolean | AutoRefreshList;
+    convertInfo?: (data?: I) => any;
+    replaceLocation?: boolean;
+    autoFetchList?: boolean;
+    debounceWait?: number;
+    onSuccess?: (action: CRUDAction, data?: any) => void;
+}
+export declare function useCRUD<I extends {
+    id: string;
+}>(options: CRUDOptions<I>): {
+    info: I;
+    list: I[];
+    infoState: import("ahooks/lib/useRequest/src/types").Result<ApiResult<I>, string[]>;
+    listState: import("ahooks/lib/useRequest/src/types").Result<ApiResult<I[]>, [params?: any]>;
+    createState: import("ahooks/lib/useRequest/src/types").Result<ApiResult<I>, [data: any]>;
+    updateState: import("ahooks/lib/useRequest/src/types").Result<ApiResult<I>, [id: string, data: any]>;
+    deleteState: import("ahooks/lib/useRequest/src/types").Result<ApiResult<I>, [id: string]>;
+    onSave: (data: I & {
+        id?: string;
+    }) => Promise<void>;
+    apis: Apis<I>;
+    loading: boolean;
+};
+export {};

package/dist/other/useCRUD.js

@@ -0,0 +1,135 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRUDAction = void 0;
+exports.useCRUD = useCRUD;
+var react_1 = require("react");
+var ahooks_1 = require("ahooks");
+var CRUDAction;
+(function (CRUDAction) {
+    CRUDAction["Info"] = "info";
+    CRUDAction["List"] = "list";
+    CRUDAction["Create"] = "create";
+    CRUDAction["Update"] = "update";
+    CRUDAction["Delete"] = "delete";
+})(CRUDAction || (exports.CRUDAction = CRUDAction = {}));
+function useCRUD(options) {
+    var _this = this;
+    var id = options.id, apis = options.apis, _a = options.autoRefreshList, autoRefreshList = _a === void 0 ? true : _a, _b = options.autoFetchList, autoFetchList = _b === void 0 ? false : _b, _c = options.replaceLocation, replaceLocation = _c === void 0 ? false : _c, _d = options.convertInfo, convertInfo = _d === void 0 ? function (data) { return data; } : _d, _e = options.onSuccess, onSuccess = _e === void 0 ? function () { return undefined; } : _e, _f = options.debounceWait, debounceWait = _f === void 0 ? 300 : _f;
+    var _g = (0, react_1.useState)([]), list = _g[0], setList = _g[1];
+    var _h = (0, react_1.useState)(), info = _h[0], setInfo = _h[1];
+    var shouldRefresh = function (action, autoRefreshList) {
+        if (typeof autoRefreshList === 'boolean') {
+            return autoRefreshList;
+        }
+        return autoRefreshList[action];
+    };
+    var infoState = (0, ahooks_1.useRequest)(apis.info, {
+        ready: !!id,
+        defaultParams: [id],
+        debounceWait: debounceWait,
+        onSuccess: function (res) {
+            var convertedInfo = convertInfo(res.data);
+            setInfo(convertedInfo);
+            onSuccess(CRUDAction.Info, convertedInfo);
+        },
+    });
+    var listState = (0, ahooks_1.useRequest)(apis.list, {
+        manual: !autoFetchList,
+        debounceWait: debounceWait,
+        onSuccess: function (res) {
+            var _a;
+            var convertedList = (_a = res.data) === null || _a === void 0 ? void 0 : _a.map(convertInfo);
+            setList(convertedList || []);
+            onSuccess(CRUDAction.List, convertedList);
+        },
+    });
+    var createState = (0, ahooks_1.useRequest)(apis.create, {
+        manual: true,
+        debounceWait: debounceWait,
+        onSuccess: function (res) {
+            if (shouldRefresh(CRUDAction.Create, autoRefreshList)) {
+                listState.run();
+            }
+            onSuccess(CRUDAction.Create, res.data);
+        },
+    });
+    var updateState = (0, ahooks_1.useRequest)(apis.update, {
+        manual: true,
+        debounceWait: debounceWait,
+        onSuccess: function (res) {
+            if (shouldRefresh(CRUDAction.Update, autoRefreshList)) {
+                listState.run();
+            }
+            onSuccess(CRUDAction.Update, res.data);
+        },
+    });
+    var deleteState = (0, ahooks_1.useRequest)(apis.delete, {
+        manual: true,
+        debounceWait: debounceWait,
+        onSuccess: function (res) {
+            if (shouldRefresh(CRUDAction.Delete, autoRefreshList)) {
+                listState.run();
+            }
+            onSuccess(CRUDAction.Delete, res.data);
+        },
+    });
+    var onSave = function (data) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (data.id) {
+                updateState.run(data.id, data);
+            }
+            else {
+                createState.run(data);
+            }
+            return [2 /*return*/];
+        });
+    }); };
+    return {
+        info: info,
+        list: list,
+        infoState: infoState,
+        listState: listState,
+        createState: createState,
+        updateState: updateState,
+        deleteState: deleteState,
+        onSave: onSave,
+        apis: apis,
+        loading: infoState.loading || listState.loading || createState.loading || updateState.loading || deleteState.loading,
+    };
+}

package/dist/other/useRequestPro.js

@@ -0,0 +1,73 @@
+// import { message } from 'antd'
+// import { useRequest } from 'ahooks'
+// import { noop, omit } from '@wzyjs/utils'
+// import { RequestRes } from '@wzyjs/types'
+// import { Options, Result, Service } from 'ahooks/lib/useRequest/src/types'
+//
+// // 在 useRequest 的基础上扩展的功能
+// interface UserOptions<P extends any[], R> extends Options<R, P> {
+//   alertErrorMessage?: false | string,
+//   alertSuccessMessage?: true | string,
+// }
+//
+// // 取出 data 里的 data
+// interface IResult<R extends RequestRes, P extends any[]> extends Omit<Result<R, P>, 'data'> {
+//   data?: R['data'],
+// }
+//
+// const defaultResult = {
+//   loading: false,
+//   data: undefined,
+//   error: undefined,
+//   params: [],
+//   cancel: noop,
+//   refresh: noop,
+//   refreshAsync: noop,
+//   run: noop,
+//   runAsync: noop,
+//   mutate: noop,
+// }
+//
+// export const useRequestPro = <P extends any[], R extends RequestRes>(
+//   reqPromise?: Service<R, P>,
+//   userOptions?: UserOptions<P, R>,
+// ): IResult<R, P> => {
+//   if (!reqPromise) {
+//     return defaultResult as IResult<R, P>
+//   }
+//
+//   const { alertErrorMessage = true, alertSuccessMessage = false } = userOptions || {}
+//
+//   const defaultOptions = {
+//     debounceWait: 300,
+//     throttleWait: 300,
+//     onError: (err: Error, params: P) => {
+//       if (alertErrorMessage) {
+//         message.error(typeof alertErrorMessage === 'string' ? alertErrorMessage : err.message || '请求失败')
+//       }
+//       userOptions?.onError?.(err, params)
+//     },
+//     onSuccess: (res: R, params: P) => {
+//       // 如果失败，则还是调用 onError
+//       if (!res?.success) {
+//         defaultOptions.onError(new Error(res?.message), params)
+//         return
+//       }
+//
+//       // 如果成功，并且需要自动弹出提示
+//       if (alertSuccessMessage) {
+//         message.success(typeof alertSuccessMessage === 'string' ? alertSuccessMessage : res.message || '请求成功')
+//       }
+//       userOptions?.onSuccess?.(res, params)
+//     },
+//   }
+//
+//   // 用户配置与默认配置合并
+//   const enableOptions = Object.assign(defaultOptions, omit(userOptions, ['onSuccess', 'onError']))
+//
+//   // 取出 data 里的 data
+//   const state = useRequest(reqPromise, enableOptions)
+//   state.data = state.data?.data
+//
+//   return state
+// }

package/dist/other/useSetting.js

@@ -0,0 +1,69 @@
+// import { useCallback, useEffect, useState } from 'react'
+//
+// export const useSetting = (key: string, defaultValue: any = {}) => {
+//   // 分割 key 以支持嵌套结构
+//   const keys = key.split('.')
+//
+//   // 获取初始值
+//   const getInitialSetting = useCallback(() => {
+//     if (typeof window === 'undefined') return defaultValue
+//     try {
+//       const stored = localStorage.getItem('settings')
+//       if (!stored) return defaultValue
+//       let result = JSON.parse(stored)
+//       for (let k of keys) {
+//         if (result[k] === undefined) {
+//           return defaultValue
+//         }
+//         result = result[k]
+//       }
+//       return result
+//     } catch (error) {
+//       console.error('从 localStorage 读取设置失败:', error)
+//       return defaultValue
+//     }
+//   }, [keys])
+//
+//   const [setting, setSettingState] = useState(getInitialSetting)
+//
+//   // 更新 localStorage
+//   const setSetting = useCallback(
+//     (newSetting: any) => {
+//       setSettingState(newSetting)
+//       if (typeof window === 'undefined') return
+//       try {
+//         const stored = localStorage.getItem('settings')
+//         const parsed = stored ? JSON.parse(stored) : {}
+//
+//         let current = parsed
+//         for (let i = 0; i < keys.length - 1; i++) {
+//           if (current[keys[i]] === undefined || typeof current[keys[i]] !== 'object') {
+//             current[keys[i]] = {}
+//           }
+//           current = current[keys[i]]
+//         }
+//         current[keys[keys.length - 1]] = newSetting
+//
+//         localStorage.setItem('settings', JSON.stringify(parsed))
+//       } catch (error) {
+//         console.error('向 localStorage 写入设置失败:', error)
+//       }
+//     },
+//     [keys],
+//   )
+//
+//   // 监听 localStorage 中 settings 的变化
+//   useEffect(() => {
+//     const handleStorageChange = (event: any) => {
+//       if (event.key === 'settings') {
+//         setSettingState(getInitialSetting())
+//       }
+//     }
+//     window.addEventListener('storage', handleStorageChange)
+//     return () => {
+//       window.removeEventListener('storage', handleStorageChange)
+//     }
+//   }, [getInitialSetting])
+//
+//   return [setting, setSetting]
+// }

package/dist/other/useUserInfo.js

@@ -0,0 +1,97 @@
+// import { useEffect, useState } from 'react'
+//
+// import { pick } from 'lodash'
+// import { useLocalStorageState, useRequest } from 'ahooks'
+//
+// import { user } from '@/services'
+// import { User, PageKey } from '@/types'
+//
+// export const useUserInfo = () => {
+//   const [token, setToken] = useLocalStorageState<user.LoginResult>('token')
+//
+//   const [userInfo, setUserInfo] = useState<User>()
+//
+//   const loginState = useRequest(user.login, {
+//     manual: true,
+//   })
+//
+//   const refreshState = useRequest(user.refresh, {
+//     manual: true,
+//   })
+//
+//   const userInfoState = useRequest(user.info, {
+//     refreshDeps: [token?.access_token],
+//     ready: !!token?.access_token,
+//     debounceWait: 300,
+//     onSuccess: res => {
+//       setUserInfo(res.data)
+//     },
+//     onError: () => {
+//       refreshToken()
+//     },
+//   })
+//
+//   const cacheToken = (data?: user.LoginResult) => {
+//     if (!data) {
+//       throw new Error('token failed')
+//     }
+//     data.expires_at = Date.now() + data.expires
+//     setToken(data)
+//   }
+//
+//   const refreshToken = async () => {
+//     const token = JSON.parse(localStorage.getItem('token') || '{}')
+//
+//     if (token?.expires_at && ((token.expires_at - Date.now()) < (30 * 1000))) {
+//       const res = await refreshState.runAsync(pick(token, 'refresh_token'))
+//       cacheToken(res.data)
+//     }
+//   }
+//
+//   const login = async (data: user.LoginData) => {
+//     if (!data) {
+//       throw new Error('data is required')
+//     }
+//
+//     const res = await loginState.runAsync(data)
+//     cacheToken(res.data)
+//   }
+//
+//   const logout = async () => {
+//     if (!token) {
+//       return
+//     }
+//     await user.logout({ refresh_token: token.refresh_token })
+//     setToken(undefined)
+//     setUserInfo(undefined)
+//     location.reload()
+//   }
+//
+//   useEffect(() => {
+//     const timer = setInterval(async () => {
+//       try {
+//         await refreshToken()
+//
+//       } catch (err) {
+//         clearInterval(timer)
+//         if (location.pathname !== PageKey.Login) {
+//           location.reload()
+//         }
+//       }
+//     }, 10 * 1000)
+//
+//     return () => {
+//       clearInterval(timer)
+//     }
+//   }, [])
+//
+//   return {
+//     login,
+//     loginLoading: loginState.loading,
+//
+//     userInfo,
+//     userInfoLoading: userInfoState.loading,
+//
+//     logout,
+//   }
+// }

package/dist/other/useWechatLogin.d.ts

@@ -0,0 +1,11 @@
+export interface WeChatLoginResult {
+    token: string;
+}
+interface wechatLoginOption {
+    onSuccess?: (loginResult: WeChatLoginResult) => void;
+}
+export declare function insertWxLoginScript(): void;
+export declare const useWechatLogin: (option: wechatLoginOption) => {
+    renderLoginView: () => void;
+};
+export {};