@douyinfe/semi-foundation 2.21.2 → 2.21.3-alpha.0

package/lib/cjs/table/foundation.d.ts

@@ -84,6 +84,18 @@ declare class TableFoundation<RecordType> extends BaseFoundation<TableAdapter<Re
     memoizedFilterColumns: (columns: BaseColumnProps<RecordType>[], ignoreKeys?: string[]) => BaseColumnProps<RecordType>[];
     memoizedFlattenFnsColumns: (columns: BaseColumnProps<RecordType>[], childrenColumnName?: string) => BaseColumnProps<RecordType>[];
     memoizedPagination: (pagination: BasePagination) => BasePagination;
+    /**
+     * update columns in place, and use default values as initial values if the sorting and filtering columns have no values
+     */
+    static initColumnsFilteredValueAndSorterOrder(columns: BaseColumnProps<unknown>[]): BaseColumnProps<unknown>[];
+    /**
+     * init filteredValue of filtering column, use defaultFilteredValue or [] when it is undefined
+     */
+    static initFilteredValue(column: BaseColumnProps<unknown>): void;
+    /**
+     * init sortOrder of sorting column, use defaultSortOrder or [] when it is undefined
+     */
+    static initSorterOrder(column: BaseColumnProps<unknown>): void;
     constructor(adapter: TableAdapter<RecordType>);
     init(): void;
     initExpandedRowKeys({ groups }?: {

package/lib/cjs/table/foundation.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
+
 var _isEqual2 = _interopRequireDefault(require("lodash/isEqual"));
 
 var _slice2 = _interopRequireDefault(require("lodash/slice"));
@@ -102,6 +104,59 @@ class TableFoundation extends _foundation.default {
     this.memoizedFlattenFnsColumns = (0, _memoizeOne.default)(_utils.flattenColumns);
     this.memoizedPagination = (0, _memoizeOne.default)(mergePagination, _isEqual2.default);
   }
+  /**
+   * update columns in place, and use default values as initial values if the sorting and filtering columns have no values
+   */
+
+
+  static initColumnsFilteredValueAndSorterOrder(columns) {
+    columns.forEach(column => {
+      TableFoundation.initFilteredValue(column);
+      TableFoundation.initSorterOrder(column);
+    });
+    return columns;
+  }
+  /**
+   * init filteredValue of filtering column, use defaultFilteredValue or [] when it is undefined
+   */
+
+
+  static initFilteredValue(column) {
+    const {
+      defaultFilteredValue,
+      filteredValue,
+      filters
+    } = column;
+    const hasFilter = Array.isArray(filters) && filters.length;
+
+    if (hasFilter && (0, _isUndefined2.default)(filteredValue)) {
+      if (Array.isArray(defaultFilteredValue) && defaultFilteredValue.length) {
+        column.filteredValue = defaultFilteredValue;
+      } else {
+        column.filteredValue = [];
+      }
+    }
+  }
+  /**
+   * init sortOrder of sorting column, use defaultSortOrder or [] when it is undefined
+   */
+
+
+  static initSorterOrder(column) {
+    const {
+      defaultSortOrder,
+      sortOrder,
+      sorter
+    } = column;
+
+    if (sorter && (0, _isUndefined2.default)(sortOrder)) {
+      if (!(0, _isUndefined2.default)(defaultSortOrder)) {
+        column.sortOrder = defaultSortOrder;
+      } else {
+        column.sortOrder = false;
+      }
+    }
+  }
 
   init() {
     const dataSource = [...this.getProp('dataSource')];

package/lib/es/table/foundation.d.ts

@@ -84,6 +84,18 @@ declare class TableFoundation<RecordType> extends BaseFoundation<TableAdapter<Re
     memoizedFilterColumns: (columns: BaseColumnProps<RecordType>[], ignoreKeys?: string[]) => BaseColumnProps<RecordType>[];
     memoizedFlattenFnsColumns: (columns: BaseColumnProps<RecordType>[], childrenColumnName?: string) => BaseColumnProps<RecordType>[];
     memoizedPagination: (pagination: BasePagination) => BasePagination;
+    /**
+     * update columns in place, and use default values as initial values if the sorting and filtering columns have no values
+     */
+    static initColumnsFilteredValueAndSorterOrder(columns: BaseColumnProps<unknown>[]): BaseColumnProps<unknown>[];
+    /**
+     * init filteredValue of filtering column, use defaultFilteredValue or [] when it is undefined
+     */
+    static initFilteredValue(column: BaseColumnProps<unknown>): void;
+    /**
+     * init sortOrder of sorting column, use defaultSortOrder or [] when it is undefined
+     */
+    static initSorterOrder(column: BaseColumnProps<unknown>): void;
     constructor(adapter: TableAdapter<RecordType>);
     init(): void;
     initExpandedRowKeys({ groups }?: {

package/lib/es/table/foundation.js

@@ -1,3 +1,4 @@
+import _isUndefined from "lodash/isUndefined";
 import _isEqual from "lodash/isEqual";
 import _slice from "lodash/slice";
 import _isMap from "lodash/isMap";
@@ -77,6 +78,59 @@ class TableFoundation extends BaseFoundation {
     this.memoizedFlattenFnsColumns = memoizeOne(flattenColumns);
     this.memoizedPagination = memoizeOne(mergePagination, _isEqual);
   }
+  /**
+   * update columns in place, and use default values as initial values if the sorting and filtering columns have no values
+   */
+
+
+  static initColumnsFilteredValueAndSorterOrder(columns) {
+    columns.forEach(column => {
+      TableFoundation.initFilteredValue(column);
+      TableFoundation.initSorterOrder(column);
+    });
+    return columns;
+  }
+  /**
+   * init filteredValue of filtering column, use defaultFilteredValue or [] when it is undefined
+   */
+
+
+  static initFilteredValue(column) {
+    const {
+      defaultFilteredValue,
+      filteredValue,
+      filters
+    } = column;
+    const hasFilter = Array.isArray(filters) && filters.length;
+
+    if (hasFilter && _isUndefined(filteredValue)) {
+      if (Array.isArray(defaultFilteredValue) && defaultFilteredValue.length) {
+        column.filteredValue = defaultFilteredValue;
+      } else {
+        column.filteredValue = [];
+      }
+    }
+  }
+  /**
+   * init sortOrder of sorting column, use defaultSortOrder or [] when it is undefined
+   */
+
+
+  static initSorterOrder(column) {
+    const {
+      defaultSortOrder,
+      sortOrder,
+      sorter
+    } = column;
+
+    if (sorter && _isUndefined(sortOrder)) {
+      if (!_isUndefined(defaultSortOrder)) {
+        column.sortOrder = defaultSortOrder;
+      } else {
+        column.sortOrder = false;
+      }
+    }
+  }
 
   init() {
     const dataSource = [...this.getProp('dataSource')];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@douyinfe/semi-foundation",
-    "version": "2.21.2",
+    "version": "2.21.3-alpha.0",
     "description": "",
     "scripts": {
         "build:lib": "node ./scripts/compileLib.js",
@@ -23,7 +23,7 @@
         "*.scss",
         "*.css"
     ],
-    "gitHead": "c587f9996fa14bbe90539099a176d79b52c849f4",
+    "gitHead": "45d27fa307080eb6ca923b8adb20ae46b90bcfdc",
     "devDependencies": {
         "@babel/plugin-transform-runtime": "^7.15.8",
         "@babel/preset-env": "^7.15.8",

package/table/foundation.ts

@@ -17,7 +17,8 @@ import {
     filter,
     isMap,
     slice,
-    isEqual
+    isEqual,
+    isUndefined
 } from 'lodash';
 import memoizeOne from 'memoize-one';
 
@@ -114,6 +115,46 @@ class TableFoundation<RecordType> extends BaseFoundation<TableAdapter<RecordType
     memoizedFlattenFnsColumns: (columns: BaseColumnProps<RecordType>[], childrenColumnName?: string) => BaseColumnProps<RecordType>[];
     memoizedPagination: (pagination: BasePagination) => BasePagination;
 
+    /**
+     * update columns in place, and use default values as initial values if the sorting and filtering columns have no values
+     */
+    static initColumnsFilteredValueAndSorterOrder(columns: BaseColumnProps<unknown>[]) {
+        columns.forEach(column => {
+            TableFoundation.initFilteredValue(column);
+            TableFoundation.initSorterOrder(column);
+        });
+        return columns;
+    }
+
+    /**
+     * init filteredValue of filtering column, use defaultFilteredValue or [] when it is undefined
+     */
+    static initFilteredValue(column: BaseColumnProps<unknown>) {
+        const { defaultFilteredValue, filteredValue, filters } = column;
+        const hasFilter = Array.isArray(filters) && filters.length;
+        if (hasFilter && isUndefined(filteredValue)) {
+            if (Array.isArray(defaultFilteredValue) && defaultFilteredValue.length) {
+                column.filteredValue = defaultFilteredValue;
+            } else {
+                column.filteredValue = [];
+            }
+        }
+    }
+
+    /**
+     * init sortOrder of sorting column, use defaultSortOrder or [] when it is undefined
+     */
+    static initSorterOrder(column: BaseColumnProps<unknown>) {
+        const { defaultSortOrder, sortOrder, sorter } = column;
+        if (sorter && isUndefined(sortOrder)) {
+            if (!isUndefined(defaultSortOrder)) {
+                column.sortOrder = defaultSortOrder;
+            } else {
+                column.sortOrder = false;
+            }
+        }
+    }
+
     constructor(adapter: TableAdapter<RecordType>) {
         super({ ...adapter });