@4399ywkf/design 1.3.12 → 2.1.0

package/dist/Table/store/slices/query/actions.js

@@ -0,0 +1,129 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import _ from 'lodash-es';
+export var createQuerySliceActions = function createQuerySliceActions(set, get, persistApi) {
+  return {
+    setPagination: function setPagination(newPage, newPageSize) {
+      var currentLimit = get().limit;
+      var pageSizeChanged = currentLimit !== undefined && currentLimit !== newPageSize;
+      set({
+        limit: newPageSize,
+        offset: pageSizeChanged ? 0 : (newPage - 1) * newPageSize
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    setFilter: function setFilter(key, value) {
+      var _get$filter;
+      var exact = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var prevFilter = _.cloneDeep((_get$filter = get().filter) !== null && _get$filter !== void 0 ? _get$filter : {});
+      var normalizedValue = value !== null && value !== void 0 ? value : [];
+      var nextFilter = _.isEmpty(value) ? Object.keys(prevFilter).reduce(function (acc, currentKey) {
+        if (currentKey !== key) {
+          acc[currentKey] = prevFilter[currentKey];
+        }
+        return acc;
+      }, {}) : _objectSpread(_objectSpread({}, prevFilter), {}, _defineProperty({}, key, {
+        value: normalizedValue,
+        exact: exact
+      }));
+      set({
+        filter: nextFilter
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    resetFilter: function resetFilter() {
+      set({
+        filter: {}
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    setSearch: function setSearch(value) {
+      set({
+        search: _.isEmpty(value) ? undefined : value
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    setSortOrder: function setSortOrder(key, value) {
+      var isMultiple = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var normalizedValue = value === 'descend' ? 'desc' : value === 'ascend' ? 'asc' : value === undefined ? undefined : value;
+      var normalizedKey = value === undefined ? undefined : key;
+      if (isMultiple) {
+        var _get$multipleSort;
+        var multipleSort = _.cloneDeep((_get$multipleSort = get().multipleSort) !== null && _get$multipleSort !== void 0 ? _get$multipleSort : []);
+        var index = multipleSort.findIndex(function (item) {
+          return item.key === normalizedKey;
+        });
+        if (normalizedValue) {
+          var nextSortItem = {
+            key: normalizedKey,
+            value: normalizedValue
+          };
+          if (index > -1) {
+            multipleSort[index] = nextSortItem;
+          } else {
+            multipleSort.push(nextSortItem);
+          }
+        } else if (index > -1) {
+          multipleSort.splice(index, 1);
+        }
+        set({
+          multipleSort: multipleSort,
+          sort: undefined,
+          order: undefined
+        });
+        persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+        return;
+      }
+      set({
+        sort: normalizedKey,
+        order: normalizedValue,
+        multipleSort: undefined
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    setOffset: function setOffset(value) {
+      set({
+        offset: value
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    setQueryData: function setQueryData(value) {
+      var _value$defaultPageSiz, _value$defaultCurrent, _value$filter, _value$total, _value$size, _value$storageName;
+      set({
+        defaultPageSize: (_value$defaultPageSiz = value.defaultPageSize) !== null && _value$defaultPageSiz !== void 0 ? _value$defaultPageSiz : get().defaultPageSize,
+        defaultCurrent: (_value$defaultCurrent = value.defaultCurrent) !== null && _value$defaultCurrent !== void 0 ? _value$defaultCurrent : get().defaultCurrent,
+        offset: value.offset,
+        limit: value.limit,
+        search: value.search,
+        filter: (_value$filter = value.filter) !== null && _value$filter !== void 0 ? _value$filter : {},
+        sort: value.sort,
+        order: value.order,
+        multipleSort: value.multipleSort,
+        total: (_value$total = value.total) !== null && _value$total !== void 0 ? _value$total : get().total,
+        size: (_value$size = value.size) !== null && _value$size !== void 0 ? _value$size : get().size,
+        storageName: (_value$storageName = value.storageName) !== null && _value$storageName !== void 0 ? _value$storageName : get().storageName
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    getQuerySnapshot: function getQuerySnapshot() {
+      return {
+        defaultPageSize: get().defaultPageSize,
+        defaultCurrent: get().defaultCurrent,
+        offset: get().offset,
+        limit: get().limit,
+        search: get().search,
+        filter: get().filter,
+        sort: get().sort,
+        order: get().order,
+        multipleSort: get().multipleSort,
+        total: get().total,
+        size: get().size,
+        storageName: get().storageName
+      };
+    }
+  };
+};

package/dist/Table/store/slices/query/initialState.d.ts

@@ -0,0 +1,2 @@
+import type { QuerySlice } from '../../types';
+export declare const queryInitialState: Pick<QuerySlice, 'defaultPageSize' | 'defaultCurrent' | 'offset' | 'limit' | 'search' | 'filter' | 'sort' | 'order' | 'multipleSort'>;

package/dist/Table/store/slices/query/initialState.js

@@ -0,0 +1,5 @@
+export var queryInitialState = {
+  defaultPageSize: 20,
+  defaultCurrent: 1,
+  filter: {}
+};

package/dist/Table/store/slices/request/actions.d.ts

@@ -0,0 +1,8 @@
+import type { StateCreator } from 'zustand';
+import type { TableStore } from '../../types';
+type Setter = Parameters<StateCreator<TableStore>>[0];
+export declare const createRequestSliceActions: (set: Setter) => {
+    setTotal: (value: number) => void;
+    setManualRequested: (value: boolean) => void;
+};
+export {};

package/dist/Table/store/slices/request/actions.js

@@ -0,0 +1,14 @@
+export var createRequestSliceActions = function createRequestSliceActions(set) {
+  return {
+    setTotal: function setTotal(value) {
+      set({
+        total: value
+      });
+    },
+    setManualRequested: function setManualRequested(value) {
+      set({
+        manualRequested: value
+      });
+    }
+  };
+};

package/dist/Table/store/slices/request/initialState.d.ts

@@ -0,0 +1,2 @@
+import type { RequestSlice } from '../../types';
+export declare const requestInitialState: Pick<RequestSlice, 'requestLoading' | 'requestError' | 'requestDataSource' | 'total' | 'manualRequested'>;

package/dist/Table/store/slices/request/initialState.js

@@ -0,0 +1,7 @@
+export var requestInitialState = {
+  requestLoading: false,
+  requestError: null,
+  requestDataSource: [],
+  total: 0,
+  manualRequested: false
+};

package/dist/Table/store/slices/ui/actions.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+import type { StateCreator } from 'zustand';
+import type { PersistSliceApi } from '../persist/api';
+import type { TableStore, TableSizeType } from '../../types';
+type Setter = Parameters<StateCreator<TableStore>>[0];
+type Getter = Parameters<StateCreator<TableStore>>[1];
+export declare const createUISliceActions: (set: Setter, get: Getter, persistApi: PersistSliceApi) => {
+    setSize: (value: TableSizeType) => void;
+    setSelectedRowKeys: (value: React.Key[]) => void;
+};
+export {};

package/dist/Table/store/slices/ui/actions.js

@@ -0,0 +1,15 @@
+export var createUISliceActions = function createUISliceActions(set, get, persistApi) {
+  return {
+    setSize: function setSize(value) {
+      set({
+        size: value
+      });
+      persistApi.persistQueryData(get().storageName, get().getQuerySnapshot());
+    },
+    setSelectedRowKeys: function setSelectedRowKeys(value) {
+      set({
+        selectedRowKeys: value
+      });
+    }
+  };
+};

package/dist/Table/store/slices/ui/initialState.d.ts

@@ -0,0 +1,2 @@
+import type { UISlice } from '../../types';
+export declare const uiInitialState: Pick<UISlice, 'size' | 'selectedRowKeys'>;

package/dist/Table/store/slices/ui/initialState.js

@@ -0,0 +1,4 @@
+export var uiInitialState = {
+  size: 'middle',
+  selectedRowKeys: []
+};

package/dist/Table/store/types.d.ts

@@ -0,0 +1,79 @@
+import type React from 'react';
+export type TableSizeType = 'large' | 'middle' | 'small';
+export type FilterInputValue = Array<React.Key | boolean>;
+export interface FilterValueItem {
+    value: FilterInputValue;
+    exact: boolean;
+}
+export type FilterMap = Record<string, FilterValueItem>;
+export interface ColumnSettingItem {
+    key: string;
+    hidden?: boolean;
+    disabled?: boolean | {
+        checkbox?: boolean;
+    };
+}
+export interface QuerySnapshot {
+    defaultPageSize: number;
+    defaultCurrent: number;
+    offset?: number;
+    limit?: number;
+    search?: string;
+    filter?: FilterMap;
+    sort?: string;
+    order?: 'descend' | 'desc' | string | null;
+    multipleSort?: Array<{
+        key?: string;
+        value?: string;
+    }>;
+    total?: number;
+    size?: TableSizeType;
+    storageName?: string;
+}
+export interface QuerySlice {
+    defaultPageSize: number;
+    defaultCurrent: number;
+    offset?: number;
+    limit?: number;
+    search?: string;
+    filter: FilterMap;
+    sort?: string;
+    order?: 'descend' | 'desc' | string | null;
+    multipleSort?: Array<{
+        key?: string;
+        value?: string;
+    }>;
+    setPagination: (newPage: number, newPageSize: number) => void;
+    setFilter: (key: string, value: FilterInputValue | null | undefined, exact?: boolean) => void;
+    resetFilter: () => void;
+    setSearch: (value: string) => void;
+    setSortOrder: (key: string, value?: 'descend' | 'ascend' | string | null, isMultiple?: boolean) => void;
+    setOffset: (value: number) => void;
+    setQueryData: (value: QuerySnapshot) => void;
+    getQuerySnapshot: () => QuerySnapshot;
+}
+export interface UISlice {
+    size?: TableSizeType;
+    selectedRowKeys: React.Key[];
+    setSize: (value: TableSizeType) => void;
+    setSelectedRowKeys: (value: React.Key[]) => void;
+}
+export interface ColumnSlice {
+    columnSetting: ColumnSettingItem[];
+    setColumnSetting: (value: ColumnSettingItem[]) => void;
+}
+export interface RequestSlice {
+    requestLoading: boolean;
+    requestError: Error | null;
+    requestDataSource: unknown[];
+    total: number;
+    manualRequested: boolean;
+    setTotal: (value: number) => void;
+    setManualRequested: (value: boolean) => void;
+}
+export interface PersistSlice {
+    storageName?: string;
+    setStorageName: (key: string) => void;
+    readLocalData: (key?: string) => void;
+}
+export type TableStore = QuerySlice & UISlice & ColumnSlice & RequestSlice & PersistSlice;

package/dist/Table/store/types.js

@@ -0,0 +1 @@
+export {};

package/dist/Table/style.d.ts

@@ -0,0 +1,3 @@
+export declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<{
+    table: import("antd-style").SerializedStyles;
+}>;

package/dist/Table/style.js

@@ -0,0 +1,10 @@
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStyles } from 'antd-style';
+export var useStyles = createStyles(function (_ref) {
+  var css = _ref.css,
+    prefixCls = _ref.prefixCls;
+  return {
+    table: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    .", "-table-title {\n      padding: 0 !important;\n    }\n  "])), prefixCls)
+  };
+});

package/dist/Table/table.d.ts

@@ -1,11 +1,5 @@
-import type { TableState } from './type';
 import React from 'react';
-import './style.css';
-type RefType = {
-    setFilter: (key: string, value: any, exact?: boolean) => void;
-    setPagination: (page: number, pageSize: number) => void;
-    setSize: (value: 'large' | 'middle' | 'small') => void;
-    queryData: any;
-} | null;
+import type { TableActionRef, TableState } from './type';
+type RefType = TableActionRef | null;
 declare const CustomTable: React.ForwardRefExoticComponent<Omit<TableState, "ref"> & React.RefAttributes<RefType>>;
 export default CustomTable;