@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/cjs/transfer/constants.d.ts

@@ -0,0 +1,10 @@
+declare const cssClasses: {
+    PREFIX: string;
+};
+declare const strings: {
+    TYPE_GROUP_LIST: string;
+    TYPE_LIST: string;
+    TYPE_TREE_TO_LIST: string;
+};
+declare const numbers: {};
+export { cssClasses, strings, numbers };

package/lib/cjs/transfer/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strings = exports.numbers = exports.cssClasses = void 0;
+
+var _constants = require("../base/constants");
+
+const cssClasses = {
+  PREFIX: `${_constants.BASE_CLASS_PREFIX}-transfer`
+};
+exports.cssClasses = cssClasses;
+const strings = {
+  TYPE_GROUP_LIST: 'groupList',
+  TYPE_LIST: 'list',
+  TYPE_TREE_TO_LIST: 'treeList'
+};
+exports.strings = strings;
+const numbers = {};
+exports.numbers = numbers;

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

@@ -0,0 +1,50 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+import { BasicValue as BasicTreeValue } from '../tree/foundation';
+export interface BasicDataItem {
+    [x: string]: any;
+    key: string | number;
+    label?: any;
+    value?: string | number;
+    disabled?: boolean;
+    style?: any;
+    className?: string;
+}
+export declare type DataItemMap = Map<number | string, BasicDataItem>;
+export interface OnSortEndProps {
+    oldIndex: number;
+    newIndex: number;
+}
+export interface BasicResolvedDataItem extends BasicDataItem {
+    _parent?: {
+        title: string;
+    };
+    _optionKey?: string | number;
+}
+export interface TransferAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    getSelected: () => DataItemMap;
+    updateSelected: (selectedItems: DataItemMap) => void;
+    notifyChange: (values: Array<number | string>, items: Array<BasicDataItem>) => void;
+    notifySearch: (input: string) => void;
+    notifySelect: (items: BasicDataItem) => void;
+    notifyDeselect: (items: BasicDataItem) => void;
+    updateInput: (input: string) => void;
+    updateSearchResult: (searchResult: Set<number | string>) => void;
+    searchTree: (keyword: string) => void;
+}
+export default class TransferFoundation<P = Record<string, any>, S = Record<string, any>> extends BaseFoundation<TransferAdapter<P, S>> {
+    constructor(adapter: TransferAdapter<P, S>);
+    _generateGroupedData(dataSource: any[]): any[];
+    _generateTreeData(dataSource: any[]): any[];
+    _generatePath(item: BasicResolvedDataItem): any;
+    handleInputChange(inputVal: string, notify: boolean): void;
+    handleAll(wantAllChecked: boolean): void;
+    handleClear(): void;
+    handleSelectOrRemove(item: BasicResolvedDataItem): void;
+    handleSelect(values: BasicTreeValue): void;
+    getValuesAndItemsFromMap(selectedItems: DataItemMap): {
+        items: any[];
+        values: any[];
+    };
+    _notifyChange(selectedItems: DataItemMap): void;
+    handleSortEnd(callbackProps: OnSortEndProps): void;
+}

package/lib/cjs/transfer/foundation.js

@@ -0,0 +1,282 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _omit2 = _interopRequireDefault(require("lodash/omit"));
+
+var _foundation = _interopRequireDefault(require("../base/foundation"));
+
+var _constants = require("./constants");
+
+var _transferUtils = require("./transferUtils");
+
+var _arrayMove = _interopRequireDefault(require("../utils/arrayMove"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-next-line max-len
+class TransferFoundation extends _foundation.default {
+  constructor(adapter) {
+    super(Object.assign({}, adapter));
+  }
+
+  _generateGroupedData(dataSource) {
+    return (0, _transferUtils._generateGroupedData)(dataSource);
+  }
+
+  _generateTreeData(dataSource) {
+    return (0, _transferUtils._generateTreeData)(dataSource);
+  }
+
+  _generatePath(item) {
+    const {
+      path = []
+    } = item;
+    return path.map(p => p.label).join(' > ');
+  }
+
+  handleInputChange(inputVal, notify) {
+    const {
+      data
+    } = this.getStates();
+    const {
+      filter,
+      type
+    } = this.getProps();
+
+    if (type === _constants.strings.TYPE_TREE_TO_LIST) {
+      const searchResult = new Set(data.map(item => item.key));
+
+      this._adapter.searchTree(inputVal);
+
+      notify && this._adapter.notifySearch(inputVal);
+
+      this._adapter.updateInput(inputVal);
+
+      this._adapter.updateSearchResult(searchResult);
+
+      return;
+    }
+
+    const filterFunc = typeof filter === 'function' ? item => filter(inputVal, item) : item => typeof item.label === 'string' && item.label.includes(inputVal);
+    const searchData = data.filter(filterFunc);
+    const searchResult = new Set(searchData.map(item => item.key));
+    notify && this._adapter.notifySearch(inputVal);
+
+    this._adapter.updateInput(inputVal);
+
+    this._adapter.updateSearchResult(searchResult);
+  } // Select or cancel all unhidden items
+
+
+  handleAll(wantAllChecked) {
+    const {
+      disabled,
+      type
+    } = this.getProps();
+    const {
+      selectedItems,
+      data,
+      searchResult,
+      inputValue
+    } = this.getStates();
+
+    if (disabled) {
+      return;
+    }
+
+    const inSearchMode = inputValue !== '';
+    let operateData = [];
+    operateData = inSearchMode ? data.filter(item => searchResult.has(item.key)) : data;
+    operateData = type === _constants.strings.TYPE_TREE_TO_LIST ? data : operateData;
+    let newSelectedItems = new Map();
+
+    switch (true) {
+      case !wantAllChecked:
+        newSelectedItems = new Map(selectedItems);
+        operateData.forEach(item => {
+          // If the item is disabled, keep it
+          if (!item.disabled) {
+            newSelectedItems.delete(item.key);
+          }
+        });
+        break;
+
+      case wantAllChecked:
+        newSelectedItems = new Map(selectedItems);
+        operateData.forEach(item => {
+          if (item.disabled) {
+            // The disabled item, judge whether it is selected, if it is selected, still need to add the selection
+            if (selectedItems.has(item.key)) {
+              newSelectedItems.set(item.key, item);
+            }
+
+            return;
+          }
+
+          newSelectedItems.set(item.key, item);
+        });
+        break;
+
+      default:
+        break;
+    }
+
+    if (!this._isControlledComponent()) {
+      this._adapter.updateSelected(newSelectedItems);
+    }
+
+    this._notifyChange(newSelectedItems);
+  }
+
+  handleClear() {
+    const {
+      disabled
+    } = this.getProps();
+    const {
+      selectedItems,
+      data
+    } = this.getStates();
+
+    if (disabled) {
+      return;
+    }
+
+    const newSelectedItems = new Map(selectedItems);
+    data.forEach(item => {
+      // If the item is disabled, keep it
+      if (!item.disabled) {
+        newSelectedItems.delete(item.key);
+      }
+    });
+
+    if (!this._isControlledComponent()) {
+      this._adapter.updateSelected(newSelectedItems);
+    }
+
+    this._notifyChange(newSelectedItems);
+  }
+
+  handleSelectOrRemove(item) {
+    const {
+      disabled
+    } = this.getProps();
+
+    const selectedItems = this._adapter.getSelected();
+
+    if (disabled || item.disabled) {
+      return;
+    }
+
+    if (selectedItems.has(item.key)) {
+      selectedItems.delete(item.key);
+
+      this._adapter.notifyDeselect(item);
+    } else {
+      selectedItems.set(item.key, item);
+
+      this._adapter.notifySelect(item);
+    }
+
+    if (!this._isControlledComponent()) {
+      this._adapter.updateSelected(selectedItems);
+    }
+
+    this._notifyChange(selectedItems);
+  }
+
+  handleSelect(values) {
+    const {
+      disabled
+    } = this.getProps();
+
+    const selectedItems = this._adapter.getSelected();
+
+    const {
+      data
+    } = this.getStates();
+    const dataItems = data.map(d => [d.value, d]);
+    const allItemsMap = new Map(dataItems);
+    const nextSelectedItemsMap = new Map();
+
+    if (disabled) {
+      return;
+    }
+
+    values.forEach(value => {
+      const node = allItemsMap.get(value); // The value passed in is an array of the value used, but the internal selectedItems stores a map of keys
+
+      if (selectedItems.has(node.key)) {
+        nextSelectedItemsMap.set(node.key, node);
+        return;
+      }
+
+      if (node.disabled) {
+        return;
+      }
+
+      nextSelectedItemsMap.set(node.key, node);
+      return;
+    });
+
+    if (!this._isControlledComponent()) {
+      this._adapter.updateSelected(nextSelectedItemsMap);
+    }
+
+    this._notifyChange(nextSelectedItemsMap);
+  }
+
+  getValuesAndItemsFromMap(selectedItems) {
+    const {
+      type
+    } = this.getProps();
+    const items = [];
+    const values = [];
+
+    for (const item of selectedItems) {
+      const obj = type === _constants.strings.TYPE_GROUP_LIST ? (0, _omit2.default)(item[1], '_parent') : item[1];
+      items.push(obj);
+      values.push(obj.value);
+    }
+
+    return {
+      items,
+      values
+    };
+  }
+
+  _notifyChange(selectedItems) {
+    const {
+      items,
+      values
+    } = this.getValuesAndItemsFromMap(selectedItems);
+
+    this._adapter.notifyChange(values, items);
+  }
+
+  handleSortEnd(callbackProps) {
+    const {
+      oldIndex,
+      newIndex
+    } = callbackProps;
+
+    const selectedItems = this._adapter.getSelected();
+
+    let selectedArr = [...selectedItems.values()];
+    selectedArr = (0, _arrayMove.default)(selectedArr, oldIndex, newIndex);
+    let newSelectedItems = new Map();
+    selectedArr.forEach(option => {
+      newSelectedItems = newSelectedItems.set(option.key, option);
+    });
+
+    this._adapter.updateSelected(newSelectedItems);
+
+    this._notifyChange(newSelectedItems);
+  }
+
+}
+
+exports.default = TransferFoundation;

package/lib/cjs/transfer/transferUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function _generateGroupedData(dataSource: any[]): any[];
+export declare function _generateTreeData(dataSource: any[]): any[];
+export declare function _generateDataByType(dataSource: any[], type: string): any[];
+export declare function _generateSelectedItems(value: any[], data: any[]): Map<any, any>;

package/lib/cjs/transfer/transferUtils.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._generateDataByType = _generateDataByType;
+exports._generateGroupedData = _generateGroupedData;
+exports._generateSelectedItems = _generateSelectedItems;
+exports._generateTreeData = _generateTreeData;
+
+var _omit2 = _interopRequireDefault(require("lodash/omit"));
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+function _generateGroupedData(dataSource) {
+  const newData = [];
+
+  for (const group of dataSource) {
+    group.children.forEach(item => {
+      const {
+        children
+      } = group,
+            rest = __rest(group, ["children"]);
+
+      newData.push(Object.assign(Object.assign({}, item), {
+        _parent: rest
+      }));
+    });
+  }
+
+  return newData;
+} // DFS
+
+
+function _generateTreeData(dataSource) {
+  const newData = [];
+  const stack = [...dataSource].reverse();
+
+  while (stack.length) {
+    const current = stack.pop();
+    current.path = current.path || [(0, _omit2.default)(current, ['children'])];
+
+    if (current.children && Array.isArray(current.children)) {
+      const nodes = current.children;
+
+      for (let i = nodes.length - 1; i >= 0; i--) {
+        const child = Object.assign({}, nodes[i]);
+        child.path = [].concat(current.path).concat((0, _omit2.default)(child, ['children']));
+        stack.push(child);
+      }
+    } else {
+      current.isLeaf = true;
+    }
+
+    newData.push((0, _omit2.default)(current, ['children']));
+  }
+
+  return newData;
+}
+
+function _generateDataByType(dataSource, type) {
+  const newData = dataSource.slice() || [];
+
+  if (type === _constants.strings.TYPE_GROUP_LIST) {
+    return _generateGroupedData(newData);
+  }
+
+  if (type === _constants.strings.TYPE_TREE_TO_LIST) {
+    return _generateTreeData(newData);
+  }
+
+  return newData;
+}
+
+function _generateSelectedItems(value, data) {
+  const selectedItems = new Map();
+  value.forEach(val => {
+    const index = data.findIndex(option => option.value === val);
+
+    if (index !== -1) {
+      const option = data[index];
+      selectedItems.set(option.key, option);
+    }
+  });
+  return selectedItems;
+}

package/lib/cjs/tree/constants.d.ts

@@ -0,0 +1,9 @@
+declare const cssClasses: {
+    PREFIX: string;
+    PREFIX_OPTION: string;
+};
+declare const strings: {
+    EXPAND_ACTION: (string | boolean)[];
+};
+declare const numbers: {};
+export { cssClasses, strings, numbers };

package/lib/cjs/tree/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strings = exports.numbers = exports.cssClasses = void 0;
+
+var _constants = require("../base/constants");
+
+const cssClasses = {
+  PREFIX: `${_constants.BASE_CLASS_PREFIX}-tree`,
+  PREFIX_OPTION: `${_constants.BASE_CLASS_PREFIX}-tree-option`
+};
+exports.cssClasses = cssClasses;
+const strings = {
+  EXPAND_ACTION: [false, 'click', 'doubleClick']
+};
+exports.strings = strings;
+const numbers = {};
+exports.numbers = numbers;