@fairys/taro-tools-react 0.0.8 → 0.0.9

package/esm/context/page.data.instance.d.ts

@@ -6,6 +6,8 @@ export interface PageDataInstanceState extends Object {
     page?: number;
     /**分页数*/
     pageSize?: number;
+    /**默认分页数*/
+    defaultPageSize?: number;
     /**总数*/
     total?: number;
     /**是否最后一页*/
@@ -17,55 +19,129 @@ export interface PageDataInstanceState extends Object {
     /**选择行数据*/
     selectedRows?: any[];
     selectedRowKeys?: any[];
+    /**一下是tab多页签使用*/
+    tabKey?: string;
+    /**tab多页签配置*/
+    tabItems?: {
+        /**tab页签key*/
+        key: string;
+        /**tab页签显示名称*/
+        label: string;
+        /**tab页签接口*/
+        api?: (payload: any, tabKey: string, instance: PageDataInstance) => Promise<{
+            code?: number;
+            data?: any;
+            message?: string;
+        }>;
+        /**tab页签默认查询参数*/
+        query?: Record<string, any>;
+        [s: string]: any;
+    }[];
+    /**是否是tab多页签*/
+    isTabs?: boolean;
+    /**是否展开查询条件*/
+    expandSearch?: boolean;
     /**数据默认值不使用*/
     __defaultValue?: string;
     [s: string]: any;
 }
 export declare class PageDataInstance<T extends PageDataInstanceState = PageDataInstanceState> extends ProxyInstanceObjectBase<T> {
+    /**不使用ref存储的字段*/
+    notRefFields: string[];
+    /**请求之前处理参数*/
+    onBefore?: (payload: any, store: T, instance: PageDataInstance<T>) => Partial<T>;
+    /**请求接口*/
+    getList?: (payload: any, instance: PageDataInstance<T>) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**请求之后处理返回值进行存储*/
+    onAfter?: (data: Record<string, any>, instance: PageDataInstance<T>) => Partial<T>;
+    /** code!==1 时 触发*/
+    onError?: (data: Record<string, any>, instance: PageDataInstance<T>) => void;
+    /**重置获取值的方法*/
+    getResetValues?: (instance: PageDataInstance<T>) => Record<string, any>;
+    /**默认查询参数*/
+    defaultQuery?: Record<string, any>;
+    /**那些字段取值对象 code值*/
+    codeFields?: string[];
+    /**那些字段取值对象的 value 值 */
+    valueFields?: string[];
     /**是否滚动加载分页*/
     is_scroll_page: boolean;
     /**默认值*/
     defaultInital: T;
-    requestConfig?: {
-        /**请求之前处理参数*/
-        onBefore?: (payload: any, store: T) => Partial<T>;
-        /**请求接口*/
-        getList?: (payload: any) => Promise<{
-            code?: number;
-            data?: any;
-            message?: string;
-        }>;
-        /**请求之后处理返回值进行存储*/
-        onAfter?: (data: Record<string, any>) => Partial<T>;
-        /** code!==1 时 触发*/
-        onError?: (data: Record<string, any>) => void;
-    };
-    constructor(options?: PageDataOptions<T>);
     store: T;
+    ctor: (options?: PageDataOptions<T>) => void;
     /**初始化状态值*/
     main_page_store: (initalValues?: Partial<T>, file?: string[]) => this;
+    /**格式化请求参数*/
+    formateParams: (params: Record<string, any>) => {};
+    /**更新查询条件*/
+    updatedSearch: (value?: Record<string, any>) => void;
     /**更新页面级的 pageLoading */
-    updatedLoading: (loading?: boolean) => void;
+    updatedPageLoading: (loading?: boolean) => void;
+    /**更新页面级的 loadMore */
+    updatedLoading: (value: Record<string, boolean>) => void;
     /**内置——查询列表*/
     main_getList: () => Promise<void>;
     /**内置——翻页*/
     main_onPageChange: (page: number) => void;
     /**内置——翻页切换*/
     main_onShowSizeChange: (_: number, pageSize: number) => void;
+    /**弹框内字段重置，如果没有获取字段值的方法，则直接清理所有字段值*/
+    main_onReset: () => void;
     /**内置——查询方法*/
     main_onSearch: () => void;
     /**加载更多*/
     main_onLoadMore: () => void;
 }
 export interface PageDataOptions<T extends PageDataInstanceState = PageDataInstanceState> {
-    /**请求配置*/
-    requestConfig?: PageDataInstance<T>['requestConfig'];
     /**初始值*/
     initialValues?: Partial<T>;
     /**是否滚动加载更多*/
     is_scroll_page?: boolean;
+    /**默认tab key*/
+    defaultTabKey?: string;
+    /**tab多页签配置*/
+    tabItems?: PageDataInstanceState['tabItems'];
+    /**默认分页数*/
+    defaultPageSize?: number;
+}
+/**初始化实例*/
+export declare function usePageDataInstance<T extends PageDataInstanceState = PageDataInstanceState>(instance?: PageDataInstance<T>): PageDataInstance<T>;
+/**页面级数据状态管理上下文*/
+export declare const PageDataInstanceContext: import("react").Context<PageDataInstance<PageDataInstanceState>>;
+/**获取上下文实例*/
+export declare const usePageDataInstanceContext: <T extends PageDataInstanceState = PageDataInstanceState>() => PageDataInstance<T>;
+export interface PageDataInstanceContextProviderProps<T extends PageDataInstanceState = PageDataInstanceState> extends PageDataOptions<T> {
+    instance?: PageDataInstance<T>;
+    children: React.ReactNode;
+    /**请求之前处理参数*/
+    onBefore?: PageDataInstance<T>['onBefore'];
+    /**请求接口*/
+    getList?: PageDataInstance<T>['getList'];
+    /**请求之后处理返回值进行存储*/
+    onAfter?: PageDataInstance<T>['onAfter'];
+    /** code!== 200 时 触发*/
+    onError?: PageDataInstance<T>['onError'];
+    /**获取弹框内重置参数*/
+    getResetValues?: PageDataInstance<T>['getResetValues'];
+    /**默认查询参数*/
+    defaultQuery?: PageDataInstance<T>['defaultQuery'];
+    /**那些字段取值对象 code值*/
+    codeFields?: PageDataInstance<T>['codeFields'];
+    /**那些字段取值对象的 value 值 */
+    valueFields?: PageDataInstance<T>['valueFields'];
+    /**是否是第一次加载*/
+    isMountLoad?: boolean;
+    /**页面标题*/
+    title?: string;
 }
+/**页面级数据状态管理上下文提供者*/
+export declare function PageDataInstanceContextProvider<T extends PageDataInstanceState = PageDataInstanceState>(props: PageDataInstanceContextProviderProps<T>): import("react/jsx-runtime").JSX.Element;
 /**
  * 页面级数据状态管理
  */
-export declare const usePageData: <T extends PageDataInstanceState = PageDataInstanceState>(options?: PageDataOptions<T>) => [T, PageDataInstance<T>, string | undefined];
+export declare const usePageDataInstanceState: <T extends PageDataInstanceState = PageDataInstanceState>() => [T, PageDataInstance<T>, string | undefined];

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

@@ -1,32 +1,49 @@
-import { proxy, ref, useSnapshot } from "valtio";
+import { jsx } from "react/jsx-runtime";
+import { proxy, ref as external_valtio_ref, useSnapshot } from "valtio";
 import { ProxyInstanceObjectBase } from "../utils/valtio/instance.js";
-import { useRef } from "react";
+import { createContext, useContext, useMemo, useRef } from "react";
 import { globalSettingDataInstance } from "./global.setting.data.instance.js";
-class PageDataInstance extends ProxyInstanceObjectBase {
+import taro, { useDidShow } from "@tarojs/taro";
+class page_data_instance_PageDataInstance extends ProxyInstanceObjectBase {
+    notRefFields = [
+        'search',
+        'loading'
+    ];
+    onBefore;
+    getList;
+    onAfter;
+    onError;
+    getResetValues;
+    defaultQuery = {};
+    codeFields = [];
+    valueFields = [];
     is_scroll_page = true;
     defaultInital = {
         page: 1,
         pageSize: 10,
         total: 0,
-        search: ref({}),
-        dataList: ref([]),
-        selectedRows: ref([]),
-        selectedRowKeys: ref([]),
+        search: {},
+        dataList: external_valtio_ref([]),
+        selectedRows: external_valtio_ref([]),
+        selectedRowKeys: external_valtio_ref([]),
         loading: {
             pageLoading: false
         },
         hasLastPage: false
     };
-    requestConfig = {};
-    constructor(options){
-        super();
-        if (options?.initialValues) this.main_page_store(options.initialValues);
-        if (options.requestConfig) this.requestConfig = options.requestConfig || {};
-        if (options?.is_scroll_page !== void 0) this.is_scroll_page = options?.is_scroll_page;
-    }
     store = 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 = external_valtio_ref(options.tabItems);
+            this.store.isTabs = Array.isArray(options.tabItems) && options.tabItems.length > 0;
+        }
+    };
     main_page_store = (initalValues = {}, file)=>{
         const newStore = {
             ...this.defaultInital,
@@ -37,77 +54,186 @@ class PageDataInstance extends ProxyInstanceObjectBase {
             'loading'
         ]);
     };
-    updatedLoading = (loading = true)=>{
+    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 ()=>{
-        if (!this.requestConfig?.getList) return void console.error("\u672A\u914D\u7F6E requestConfig.getList \u8BF7\u6C42\u65B9\u6CD5");
+        let pageField = 'page';
+        let pageSizeField = 'pageSize';
+        let dataListField = 'dataList';
+        let totalField = 'total';
+        let selectedRowsField = 'selectedRows';
+        let selectedRowKeysField = 'selectedRowKeys';
+        let _request;
+        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`;
+        } else _request = this.getList;
+        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.showLoading({
+            title: "\u52A0\u8F7D\u4E2D..."
+        });
         try {
-            this.updatedLoading(true);
+            this.updatedPageLoading(true);
             const payload = {
+                ...this.defaultQuery,
+                ...defaultQuery,
                 ...this.store.search,
-                page: this.store.page,
-                pageSize: this.store.pageSize
+                page: this.store[pageField] || 1,
+                pageSize: this.store[pageSizeField] || this.store.defaultPageSize || 20
             };
-            let newParams = {
+            let newParams = this.formateParams({
                 ...payload
-            };
-            if (this.requestConfig?.onBefore) newParams = this.requestConfig.onBefore(payload, this.store);
-            const result = await this.requestConfig.getList?.(newParams);
-            this.updatedLoading(false);
+            });
+            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 === globalSettingDataInstance.store.requestSuccessCode) {
                 let saveData = {};
-                if (this.requestConfig?.onAfter) saveData = this.requestConfig.onAfter(result);
+                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.page) newDataList = dataList;
+                    if (1 === this.store[pageField]) newDataList = dataList;
                     else if (this.is_scroll_page) newDataList = [
-                        ...this.store.dataList,
+                        ...this.store[dataListField] || [],
                         ...dataList
                     ];
                     saveData = {
-                        dataList: newDataList,
-                        total: result?.data?.total || 0
+                        [dataListField]: newDataList,
+                        [totalField]: result?.data?.total || 0
                     };
-                    if (1 === this.store.page) {
-                        saveData.selectedRows = ref([]);
-                        saveData.selectedRowKeys = ref([]);
+                    if (1 === this.store[pageField]) {
+                        saveData[selectedRowsField] = external_valtio_ref([]);
+                        saveData[selectedRowKeysField] = external_valtio_ref([]);
                     }
                 }
                 if (saveData) this._setValues(saveData);
-            } else if (this.requestConfig?.onError) this.requestConfig.onError(result);
+            } else if (this.onError) this.onError(result, this);
         } catch (error) {
             console.log(error);
             this.store.loading.loadMore = false;
-            this.updatedLoading(false);
+            this.updatedPageLoading(false);
         }
+        taro.hideLoading();
     };
     main_onPageChange = (page)=>{
-        this._setValues({
+        if (this.store.isTabs) {
+            const tabKey = this.store.tabKey;
+            this._setValues({
+                [`${tabKey}Page`]: 1
+            });
+        } else this._setValues({
             page
         });
         this.main_getList();
     };
     main_onShowSizeChange = (_, pageSize)=>{
-        this._setValues({
+        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 = ()=>{
         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,
+                [`${tabKey}HasLastPage`]: hasLastPage
+            });
+            this.main_getList();
+            return;
+        }
         const total = this.store.total || 0;
         const page = this.store.page || 1;
-        const pageSize = this.store.pageSize || 20;
+        const pageSize = this.store.pageSize || this.store.defaultPageSize || 20;
         const count = Math.ceil(total / pageSize);
         let hasLastPage = false;
         if (page >= count && total) {
@@ -127,13 +253,58 @@ class PageDataInstance extends ProxyInstanceObjectBase {
         this.main_getList();
     };
 }
-const usePageData = (options = {})=>{
-    const pageDataInstance = useRef(new PageDataInstance(options)).current;
-    const store = useSnapshot(pageDataInstance.store);
+function usePageDataInstance(instance) {
+    const ref = useRef();
+    if (!ref.current) ref.current = instance || new page_data_instance_PageDataInstance();
+    return ref.current;
+}
+const PageDataInstanceContext = /*#__PURE__*/ createContext(new page_data_instance_PageDataInstance());
+const usePageDataInstanceContext = ()=>{
+    const PageDataInstance = useContext(PageDataInstanceContext);
+    return PageDataInstance;
+};
+function PageDataInstanceContextProvider(props) {
+    const { instance, children, initialValues, is_scroll_page, defaultTabKey, tabItems, defaultPageSize, onBefore, getList, onAfter, onError, getResetValues, defaultQuery, codeFields, valueFields, isMountLoad, title } = props;
+    const pageInstance = usePageDataInstance(instance);
+    instance.onBefore = onBefore;
+    instance.getList = getList;
+    instance.onAfter = onAfter;
+    instance.onError = onError;
+    instance.getResetValues = getResetValues;
+    instance.codeFields = codeFields;
+    instance.valueFields = valueFields;
+    instance.defaultQuery = defaultQuery;
+    useMemo(()=>pageInstance.ctor({
+            initialValues,
+            is_scroll_page,
+            defaultTabKey,
+            tabItems,
+            defaultPageSize
+        }), [
+        pageInstance
+    ]);
+    useMemo(()=>{
+        if (isMountLoad) pageInstance.main_onSearch();
+    }, []);
+    useDidShow(()=>{
+        if (title) taro.setNavigationBarTitle({
+            title
+        });
+    });
+    return /*#__PURE__*/ jsx(PageDataInstanceContext.Provider, {
+        value: pageInstance,
+        children: children
+    });
+}
+const usePageDataInstanceState = ()=>{
+    const PageMainDataInstance = usePageDataInstanceContext();
+    const store = useSnapshot(PageMainDataInstance.store, {
+        sync: true
+    });
     return [
         store,
-        pageDataInstance,
+        PageMainDataInstance,
         store.__defaultValue
     ];
 };
-export { PageDataInstance, usePageData };
+export { page_data_instance_PageDataInstance as PageDataInstance, PageDataInstanceContext, PageDataInstanceContextProvider, usePageDataInstance, usePageDataInstanceContext, usePageDataInstanceState };

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

@@ -13,41 +13,42 @@ export interface PageInfoDataInstanceState extends Object {
     [s: string]: any;
 }
 export declare class PageInfoDataInstance<T extends PageInfoDataInstanceState = PageInfoDataInstanceState> extends ProxyInstanceObjectBase<T> {
+    notRefFields: string[];
     /**默认值*/
     defaultInital: T;
     requestInfoConfig?: {
         /**详情查询-请求之前处理参数*/
-        onBefore?: (store: T) => Promise<Partial<T>> | Partial<T>;
+        onBefore?: (store: T, instance: PageInfoDataInstance<T>) => Promise<Partial<T>> | Partial<T>;
         /**详情查询-请求接口*/
-        getInfo?: (payload: any) => Promise<{
+        getInfo?: (payload: any, instance: PageInfoDataInstance<T>) => Promise<{
             code?: number;
             data?: any;
             message?: string;
         }>;
         /**详情查询-请求之后处理返回值进行存储*/
-        onAfter?: (data: Record<string, any>) => Partial<T>;
+        onAfter?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => Partial<T>;
         /**详情查询-code!==1 时 触发*/
-        onError?: (data: Record<string, any>) => void;
+        onError?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => void;
     };
     requestSaveInfoConfig?: {
         /**详情保存-请求之前处理参数*/
-        onSaveBefore?: (store: T) => Promise<Record<string, any>> | Record<string, any>;
+        onSaveBefore?: (store: T, instance: PageInfoDataInstance<T>) => Promise<Record<string, any>> | Record<string, any>;
         /**详情保存接口*/
-        onSaveInfo?: (payload: any) => Promise<{
+        onSaveInfo?: (payload: any, instance: PageInfoDataInstance<T>) => Promise<{
             code?: number;
             data?: any;
             message?: string;
         }>;
         /**详情保存-请求之后处理返回值进行存储*/
-        onSaveAfter?: (data: Record<string, any>) => void;
+        onSaveAfter?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => void;
         /**详情查询-code!==1 时 触发*/
-        onSaveError?: (data: Record<string, any>) => void;
+        onSaveError?: (data: Record<string, any>, instance: PageInfoDataInstance<T>) => void;
         /**保存成功-跳转页面*/
         saveSuccessNavigate?: string | 'navigateBack' | number | ((data: any) => void);
         /**是否显示成功提示*/
         isShowSuccessMessage?: boolean;
     };
-    constructor(options?: PageInfoDataOptions<T>);
+    ctor(options?: PageInfoDataOptions<T>): void;
     store: T;
     /**初始化状态值*/
     main_page_store: (initalValues?: Partial<T>, file?: string[]) => this;
@@ -65,8 +66,28 @@ export interface PageInfoDataOptions<T extends PageInfoDataInstanceState = PageI
     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 usePageInfoData: <T extends PageInfoDataInstanceState = PageInfoDataInstanceState>(options?: PageInfoDataOptions<T>) => [T, PageInfoDataInstance<T>, string | undefined];
+export declare const usePageInfoDataInstanceState: <T extends PageInfoDataInstanceState = PageInfoDataInstanceState>() => [T, PageInfoDataInstance<T>, string | undefined];