@fairys/taro-tools-react 1.0.4 → 1.0.6

package/lib/context/page.data.instance.js

@@ -0,0 +1,382 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PageDataInstanceContextProvider: ()=>PageDataInstanceContextProvider,
+    usePageDataInstance: ()=>usePageDataInstance,
+    PageDataInstance: ()=>page_data_instance_PageDataInstance,
+    usePageDataInstanceContext: ()=>usePageDataInstanceContext,
+    usePageDataInstanceState: ()=>usePageDataInstanceState,
+    PageDataInstanceContext: ()=>PageDataInstanceContext
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_valtio_namespaceObject = require("valtio");
+const instance_js_namespaceObject = require("../utils/valtio/instance.js");
+const external_react_namespaceObject = require("react");
+const external_global_setting_data_instance_js_namespaceObject = require("./global.setting.data.instance.js");
+const taro_namespaceObject = require("@tarojs/taro");
+var taro_default = /*#__PURE__*/ __webpack_require__.n(taro_namespaceObject);
+class page_data_instance_PageDataInstance extends instance_js_namespaceObject.ProxyInstanceObjectBase {
+    notRefFields = [
+        'search',
+        'loading'
+    ];
+    onBefore;
+    getList;
+    onAfter;
+    onExtraData;
+    onError;
+    getResetValues;
+    defaultQuery = {};
+    codeFields = [];
+    valueFields = [];
+    is_scroll_page = true;
+    defaultInital = {
+        page: 1,
+        pageSize: 10,
+        total: 0,
+        search: {},
+        dataList: (0, external_valtio_namespaceObject.ref)([]),
+        selectedRows: (0, external_valtio_namespaceObject.ref)([]),
+        selectedRowKeys: (0, external_valtio_namespaceObject.ref)([]),
+        loading: {
+            pageLoading: false
+        },
+        hasLastPage: false
+    };
+    store = (0, external_valtio_namespaceObject.proxy)({
+        ...this.defaultInital
+    });
+    ctor = (options)=>{
+        if (options?.initialValues) this.main_page_store(options.initialValues);
+        if (options.defaultPageSize) this.store.defaultPageSize = options.defaultPageSize;
+        if (options?.is_scroll_page !== void 0) this.is_scroll_page = options?.is_scroll_page;
+        if (options?.defaultTabKey) this.store.tabKey = options.defaultTabKey;
+        if (options?.tabItems) {
+            this.store.tabItems = (0, external_valtio_namespaceObject.ref)(options.tabItems);
+            this.store.isTabs = Array.isArray(options.tabItems) && options.tabItems.length > 0;
+        }
+    };
+    main_page_store = (initalValues = {}, file)=>{
+        const newStore = {
+            ...this.defaultInital,
+            ...initalValues
+        };
+        return this._ctor(newStore, [
+            ...file || [],
+            'loading'
+        ]);
+    };
+    formateParams = (params)=>{
+        const _query = {};
+        const keys = Object.keys(params);
+        for(let index = 0; index < keys.length; index++){
+            const key = keys[index];
+            if ((this.valueFields || []).includes(key)) _query[key] = params[key]?.value;
+            else if ((this.codeFields || []).includes(key)) _query[key] = params[key]?.code;
+            else _query[key] = params[key];
+        }
+        return {
+            ..._query
+        };
+    };
+    updatedSearch = (value = {})=>{
+        const keys = Object.keys(value);
+        if (!this.store.search) this.store.search = {};
+        for(let index = 0; index < keys.length; index++){
+            const key = keys[index];
+            this.store.search[key] = value[key];
+        }
+    };
+    updatedPageLoading = (loading = true)=>{
+        if ('object' == typeof this.store?.loading) this.store.loading.pageLoading = loading;
+        else this.store.loading = {
+            pageLoading: loading
+        };
+    };
+    updatedLoading = (value)=>{
+        if ('object' == typeof this.store?.loading) this.store.loading = {
+            ...this.store.loading,
+            ...value
+        };
+        else this.store.loading = {
+            ...value
+        };
+    };
+    main_getList = async ()=>{
+        let pageField = 'page';
+        let pageSizeField = 'pageSize';
+        let dataListField = 'dataList';
+        let totalField = 'total';
+        let selectedRowsField = 'selectedRows';
+        let selectedRowKeysField = 'selectedRowKeys';
+        let _request = this.getList;
+        let defaultQuery = {};
+        if (this.store.isTabs) {
+            const tabKey = this.store.tabKey;
+            const findTab = this.store.tabItems?.find((item)=>item.key === tabKey);
+            if (findTab?.api) _request = findTab.api;
+            defaultQuery = findTab?.query || {};
+            pageField = `${tabKey}Page`;
+            pageSizeField = `${tabKey}PageSize`;
+            dataListField = `${tabKey}DataList`;
+            totalField = `${tabKey}Total`;
+            selectedRowsField = `${tabKey}SelectedRows`;
+            selectedRowKeysField = `${tabKey}SelectedRowKeys`;
+        }
+        if (!_request) return void console.error("\u672A\u914D\u7F6E getList \u8BF7\u6C42\u65B9\u6CD5,\u8BF7\u68C0\u67E5\u662F\u5426\u914D\u7F6E\u4E86 getList \u65B9\u6CD5");
+        taro_default().showLoading({
+            title: "\u52A0\u8F7D\u4E2D..."
+        });
+        try {
+            this.updatedPageLoading(true);
+            const payload = {
+                ...this.defaultQuery,
+                ...defaultQuery,
+                ...this.store.search,
+                page: this.store[pageField] || 1,
+                pageSize: this.store[pageSizeField] || this.store.defaultPageSize || 20
+            };
+            let newParams = this.formateParams({
+                ...payload
+            });
+            if (this.onBefore) newParams = this.onBefore(payload, this.store, this);
+            const result = await this.getList?.(newParams, this);
+            this.updatedPageLoading(false);
+            this.store.loading.loadMore = false;
+            if (result && result.code === external_global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.requestSuccessCode) {
+                let saveData = {};
+                if (this.onAfter) saveData = this.onAfter(result, this);
+                else {
+                    const dataList = result?.data?.list || result?.data?.rows || result?.data?.records || [];
+                    let newDataList = [];
+                    if (1 === this.store[pageField]) newDataList = dataList;
+                    else if (this.is_scroll_page) newDataList = [
+                        ...this.store[dataListField] || [],
+                        ...dataList
+                    ];
+                    saveData = {
+                        [dataListField]: newDataList,
+                        [totalField]: result?.data?.total || 0
+                    };
+                    if (1 === this.store[pageField] || !this.is_scroll_page) {
+                        saveData[selectedRowsField] = (0, external_valtio_namespaceObject.ref)([]);
+                        saveData[selectedRowKeysField] = (0, external_valtio_namespaceObject.ref)([]);
+                    }
+                }
+                if (this.onExtraData) {
+                    const _temps = this.onExtraData(result, this);
+                    saveData = {
+                        ...saveData,
+                        ..._temps || {}
+                    };
+                }
+                if (saveData) this._setValues(saveData);
+            } else if (this.onError) this.onError(result, this);
+        } catch (error) {
+            console.log(error);
+            this.store.loading.loadMore = false;
+            this.updatedPageLoading(false);
+        }
+        taro_default().hideLoading();
+    };
+    main_onPageChange = (page)=>{
+        if (this.store.isTabs) {
+            const tabKey = this.store.tabKey;
+            this._setValues({
+                [`${tabKey}Page`]: 1
+            });
+        } else this._setValues({
+            page
+        });
+        this.main_getList();
+    };
+    main_onShowSizeChange = (_, pageSize)=>{
+        if (this.store.isTabs) {
+            const tabKey = this.store.tabKey;
+            this._setValues({
+                [`${tabKey}Page`]: 1,
+                [`${tabKey}PageSize`]: pageSize
+            });
+        } else this._setValues({
+            page: 1,
+            pageSize
+        });
+        this.main_getList();
+    };
+    main_onReset = ()=>{
+        if (this.getResetValues) {
+            const values = this.getResetValues(this);
+            if (values) this.updatedSearch({
+                ...values
+            });
+        } else {
+            const keys = Object.keys(this.store.search || {});
+            for(let index = 0; index < keys.length; index++){
+                const key = keys[index];
+                this.store.search[key] = void 0;
+            }
+        }
+    };
+    main_onSearch = ()=>{
+        this.main_onPageChange(1);
+        this.store.expandSearch = false;
+    };
+    main_onLoadMore = async ()=>{
+        if (this.store.loading?.pageLoading) return;
+        const isTabs = this.store.isTabs;
+        if (isTabs) {
+            const tabKey = this.store.tabKey;
+            const total = this.store[`${tabKey}Total`] || 0;
+            const page = this.store[`${tabKey}Page`] || 1;
+            const pageSize = this.store[`${tabKey}PageSize`] || this.store.defaultPageSize || 20;
+            const count = Math.ceil(total / pageSize);
+            let hasLastPage = false;
+            if (page >= count && total) {
+                hasLastPage = true;
+                this._setValues({
+                    [`${tabKey}HasLastPage`]: hasLastPage
+                });
+                return;
+            }
+            const nextPage = page + 1;
+            if (nextPage >= count && total) hasLastPage = true;
+            this.updatedLoading({
+                [`${tabKey}LoadMore`]: true
+            });
+            this._setValues({
+                [`${tabKey}Page`]: nextPage
+            });
+            await this.main_getList();
+            this._setValues({
+                [`${tabKey}HasLastPage`]: hasLastPage
+            });
+            return;
+        }
+        const total = this.store.total || 0;
+        const page = this.store.page || 1;
+        const pageSize = this.store.pageSize || this.store.defaultPageSize || 20;
+        const count = Math.ceil(total / pageSize);
+        let hasLastPage = false;
+        if (page >= count && total) {
+            hasLastPage = true;
+            this._setValues({
+                hasLastPage
+            });
+            return;
+        }
+        const nextPage = page + 1;
+        if (nextPage >= count && total) hasLastPage = true;
+        this.store.loading.loadMore = true;
+        this._setValues({
+            page: nextPage
+        });
+        await this.main_getList();
+        this._setValues({
+            hasLastPage
+        });
+    };
+}
+function usePageDataInstance(instance) {
+    const ref = (0, external_react_namespaceObject.useRef)();
+    if (!ref.current) ref.current = instance || new page_data_instance_PageDataInstance();
+    return ref.current;
+}
+const PageDataInstanceContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(new page_data_instance_PageDataInstance());
+const usePageDataInstanceContext = ()=>{
+    const PageDataInstance = (0, external_react_namespaceObject.useContext)(PageDataInstanceContext);
+    return PageDataInstance;
+};
+function PageDataInstanceContextProvider(props) {
+    const { instance, children, initialValues, is_scroll_page, defaultTabKey, tabItems, defaultPageSize, onBefore, getList, onAfter, onExtraData, onError, getResetValues, defaultQuery, codeFields, valueFields, isMountLoad, title } = props;
+    const pageInstance = usePageDataInstance(instance);
+    instance.onBefore = onBefore;
+    instance.getList = getList;
+    instance.onAfter = onAfter;
+    instance.onExtraData = onExtraData;
+    instance.onError = onError;
+    instance.getResetValues = getResetValues;
+    instance.codeFields = codeFields;
+    instance.valueFields = valueFields;
+    instance.defaultQuery = defaultQuery;
+    (0, external_react_namespaceObject.useMemo)(()=>pageInstance.ctor({
+            initialValues,
+            is_scroll_page,
+            defaultTabKey,
+            tabItems,
+            defaultPageSize
+        }), [
+        pageInstance
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (isMountLoad) pageInstance.main_onSearch();
+    }, []);
+    (0, taro_namespaceObject.useDidShow)(()=>{
+        if (title) taro_default().setNavigationBarTitle({
+            title
+        });
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(PageDataInstanceContext.Provider, {
+        value: pageInstance,
+        children: children
+    });
+}
+const usePageDataInstanceState = ()=>{
+    const PageMainDataInstance = usePageDataInstanceContext();
+    const store = (0, external_valtio_namespaceObject.useSnapshot)(PageMainDataInstance.store, {
+        sync: true
+    });
+    return [
+        store,
+        PageMainDataInstance,
+        store.__defaultValue
+    ];
+};
+exports.PageDataInstance = __webpack_exports__.PageDataInstance;
+exports.PageDataInstanceContext = __webpack_exports__.PageDataInstanceContext;
+exports.PageDataInstanceContextProvider = __webpack_exports__.PageDataInstanceContextProvider;
+exports.usePageDataInstance = __webpack_exports__.usePageDataInstance;
+exports.usePageDataInstanceContext = __webpack_exports__.usePageDataInstanceContext;
+exports.usePageDataInstanceState = __webpack_exports__.usePageDataInstanceState;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PageDataInstance",
+    "PageDataInstanceContext",
+    "PageDataInstanceContextProvider",
+    "usePageDataInstance",
+    "usePageDataInstanceContext",
+    "usePageDataInstanceState"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/context/page.info.data.instance.d.ts

@@ -0,0 +1,93 @@
+import { ProxyInstanceObjectBase } from '../utils/valtio/instance';
+export interface PageInfoDataInstanceState extends Object {
+    /**loading存储*/
+    loading?: Record<string, boolean>;
+    /**编辑表单数据*/
+    editFormData?: Record<string, any>;
+    /**编辑类型*/
+    editType?: 'add' | 'edit' | 'info';
+    /**查询详情是否成功*/
+    isInfoSuccess?: boolean;
+    /**数据默认值不使用*/
+    __defaultValue?: string;
+    [s: string]: any;
+}
+export declare class PageInfoDataInstance<T extends PageInfoDataInstanceState = PageInfoDataInstanceState> extends ProxyInstanceObjectBase<T> {
+    notRefFields: string[];
+    /**默认值*/
+    defaultInital: T;
+    requestInfoConfig?: {
+        /**详情查询-请求之前处理参数*/
+        onBefore?: (store: T, instance: PageInfoDataInstance<T>) => Promise<Partial<T>> | Partial<T>;
+        /**详情查询-请求接口*/
+        getInfo?: (payload: any, instance: PageInfoDataInstance<T>) => Promise<{
+            code?: number;
+            data?: any;
+            message?: string;
+        }>;
+        /**详情查询-请求之后处理返回值进行存储*/
+        onAfter?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => Partial<T>;
+        /**详情查询-code!==1 时 触发*/
+        onError?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => void;
+    };
+    requestSaveInfoConfig?: {
+        /**详情保存-请求之前处理参数*/
+        onSaveBefore?: (store: T, instance: PageInfoDataInstance<T>) => Promise<Record<string, any>> | Record<string, any>;
+        /**详情保存接口*/
+        onSaveInfo?: (payload: any, instance: PageInfoDataInstance<T>) => Promise<{
+            code?: number;
+            data?: any;
+            message?: string;
+        }>;
+        /**详情保存-请求之后处理返回值进行存储*/
+        onSaveAfter?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => void;
+        /**详情查询-code!==1 时 触发*/
+        onSaveError?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => void;
+        /**保存成功-跳转页面*/
+        saveSuccessNavigate?: string | 'navigateBack' | number | ((data: any) => void);
+        /**是否显示成功提示*/
+        isShowSuccessMessage?: boolean;
+    };
+    ctor(options?: PageInfoDataOptions<T>): void;
+    store: T;
+    /**初始化状态值*/
+    main_page_store: (initalValues?: Partial<T>, file?: string[]) => this;
+    /**更新页面级的 pageLoading */
+    updatedLoading: (loading?: boolean) => void;
+    /**内置——查询详细信息*/
+    main_getInfo: () => Promise<void>;
+    /**保存数据*/
+    main_saveInfo: () => Promise<void>;
+}
+export interface PageInfoDataOptions<T extends PageInfoDataInstanceState = PageInfoDataInstanceState> {
+    /**详情查询请求配置*/
+    requestInfoConfig?: PageInfoDataInstance<T>['requestInfoConfig'];
+    /**详情保存请求配置*/
+    requestSaveInfoConfig?: PageInfoDataInstance<T>['requestSaveInfoConfig'];
+    /**初始值*/
+    initialValues?: Partial<T>;
+    /**editFormData是否使用valtio proxy 存储*/
+    isProxy?: boolean;
+}
+/**初始化实例*/
+export declare const usePageInfoDataInstance: <T extends PageInfoDataInstanceState = PageInfoDataInstanceState>(instance?: PageInfoDataInstance<T>) => PageInfoDataInstance<T>;
+/**页面级数据状态管理上下文*/
+export declare const PageInfoDataInstanceContext: import("react").Context<PageInfoDataInstance<PageInfoDataInstanceState>>;
+/**获取上下文实例*/
+export declare const usePageInfoDataInstanceContext: <T extends PageInfoDataInstanceState = PageInfoDataInstanceState>() => PageInfoDataInstance<T>;
+export interface PageInfoDataInstanceContextProviderProps<T extends PageInfoDataInstanceState = PageInfoDataInstanceState> extends PageInfoDataOptions<T> {
+    instance?: PageInfoDataInstance<T>;
+    children: React.ReactNode;
+    /**页面标题*/
+    title?: string;
+    /**页面一加载是否请求详情接口*/
+    isMountRequestInfo?: boolean;
+    /**自定义hooks,挂载参数和设置完初始值后执行*/
+    useHooks?: (instance: PageInfoDataInstance<T>) => void;
+}
+/**页面级数据状态管理上下文提供者*/
+export declare function PageInfoDataInstanceContextProvider<T extends PageInfoDataInstanceState = PageInfoDataInstanceState>(props: PageInfoDataInstanceContextProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+/**
+ * 页面级数据状态管理
+ */
+export declare const usePageInfoDataInstanceState: <T extends PageInfoDataInstanceState = PageInfoDataInstanceState>() => [T, PageInfoDataInstance<T>, string | undefined];