shineout 1.12.2 → 1.12.3

package/esm/Select/filter.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import React from 'react';
+import { ResultValue, SelectPropsWidthTiled, SelectPropsWidthFilter } from './Props';
+interface FilterState<Item> {
+    innerFilter: undefined | ((data: Item) => boolean);
+    innerData: undefined;
+    filterText: string;
+    text: string;
+}
+declare const _default: <Item, Value>(Origin: React.ComponentType<SelectPropsWidthTiled<Item, Value>>) => {
+    new (props: SelectPropsWidthFilter<Item, Value>): {
+        resultCache: Map<Value, Item>;
+        timer: NodeJS.Timer;
+        componentDidUpdate(prevProps: SelectPropsWidthFilter<Item, Value>): void;
+        getTreeResult(value: Value, prediction: (value: Value, data: Item) => boolean): Item | undefined;
+        getResult(value: Value): Item | undefined;
+        getResultByValues(): (Item | ResultValue<Value>)[];
+        handleFilter(text: string, from?: string): void;
+        handleCreate(text: string): any;
+        filterTreeData(): {
+            treeData: (Item | null)[] | undefined;
+            expanded: any;
+            rawData: Item[] | undefined;
+        };
+        filterData(): {
+            data: Item[] | undefined;
+        };
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof FilterState<Item>>(state: FilterState<Item> | ((prevState: Readonly<FilterState<Item>>, props: Readonly<SelectPropsWidthFilter<Item, Value>>) => FilterState<Item> | Pick<FilterState<Item>, K> | null) | Pick<FilterState<Item>, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<SelectPropsWidthFilter<Item, Value>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<FilterState<Item>>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<SelectPropsWidthFilter<Item, Value>>, nextState: Readonly<FilterState<Item>>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<SelectPropsWidthFilter<Item, Value>>, prevState: Readonly<FilterState<Item>>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<SelectPropsWidthFilter<Item, Value>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<SelectPropsWidthFilter<Item, Value>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<SelectPropsWidthFilter<Item, Value>>, nextState: Readonly<FilterState<Item>>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<SelectPropsWidthFilter<Item, Value>>, nextState: Readonly<FilterState<Item>>, nextContext: any): void;
+    };
+    defaultProps: {
+        data: never[];
+        filterDelay: number;
+        showHitDescendants: boolean;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/esm/Select/filter.js

@@ -0,0 +1,272 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { getKey } from '../utils/uid';
+import { getFilterTree } from '../utils/tree';
+import { IS_NOT_MATCHED_VALUE } from './Result';
+export default (function (Origin) {
+  var _class, _temp;
+
+  return _temp = _class =
+  /*#__PURE__*/
+  function (_React$Component) {
+    _inheritsLoose(Filter, _React$Component);
+
+    function Filter(props) {
+      var _this;
+
+      _this = _React$Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "resultCache", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "timer", void 0);
+
+      _this.state = {
+        innerFilter: undefined,
+        innerData: undefined,
+        filterText: '',
+        text: ''
+      };
+      _this.handleCreate = _this.handleCreate.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleFilter = _this.handleFilter.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.getResultByValues = _this.getResultByValues.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.resultCache = new Map();
+      return _this;
+    }
+
+    var _proto = Filter.prototype;
+
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+      var _this$props = this.props,
+          datum = _this$props.datum,
+          multiple = _this$props.multiple;
+
+      if (prevProps.multiple !== multiple) {
+        datum.limit = multiple ? 0 : 1;
+      }
+    };
+
+    _proto.getTreeResult = function getTreeResult(value, prediction) {
+      var _this$props2 = this.props,
+          treeData = _this$props2.treeData,
+          _this$props2$children = _this$props2.childrenKey,
+          childrenKey = _this$props2$children === void 0 ? 'children' : _this$props2$children;
+      var finded;
+
+      var treeNode = function treeNode(children) {
+        if (finded) return false;
+        if (!children || children.length === 0) return false;
+
+        for (var i = 0; i < children.length; i++) {
+          var d = children[i];
+          if (prediction(value, d)) finded = d; // @ts-ignore
+
+          treeNode(d[childrenKey]);
+        }
+
+        return false;
+      };
+
+      treeNode(treeData);
+      return finded;
+    };
+
+    _proto.getResult = function getResult(value) {
+      var _this$props3 = this.props,
+          data = _this$props3.data,
+          treeData = _this$props3.treeData,
+          datum = _this$props3.datum,
+          onCreate = _this$props3.onCreate;
+
+      var prediction = datum.prediction || function (v, d) {
+        return v === datum.format(d);
+      };
+
+      if (treeData) return this.getTreeResult(value, prediction);
+
+      for (var i = 0, count = data.length; i < count; i++) {
+        var d = data[i];
+        if (prediction(value, d)) return d;
+      }
+
+      if (onCreate) return this.handleCreate(value);
+      return undefined;
+    };
+
+    _proto.getResultByValues = function getResultByValues() {
+      var _this2 = this;
+
+      var _this$props4 = this.props,
+          datum = _this$props4.datum,
+          noCache = _this$props4.noCache;
+      var _datum$values = datum.values,
+          values = _datum$values === void 0 ? [] : _datum$values;
+      var result = [];
+      values.forEach(function (v) {
+        var res = noCache ? undefined : _this2.resultCache.get(v);
+
+        if (!res) {
+          var _res;
+
+          res = _this2.getResult(v);
+          if (res !== undefined && !noCache) _this2.resultCache.set(v, res);else if (res === undefined) res = (_res = {}, _res[IS_NOT_MATCHED_VALUE] = true, _res.value = v, _res);
+        }
+
+        if (res !== undefined) {
+          result.push(res);
+        }
+      });
+      return result;
+    };
+
+    _proto.handleFilter = function handleFilter(text, from) {
+      var _this3 = this;
+
+      if (from === void 0) {
+        from = 'edit';
+      }
+
+      var _this$props5 = this.props,
+          filterDelay = _this$props5.filterDelay,
+          onFilter = _this$props5.onFilter,
+          onCreate = _this$props5.onCreate;
+      this.setState({
+        text: text
+      }); // not filter
+
+      if (!text) {
+        this.setState({
+          filterText: '',
+          innerFilter: undefined,
+          innerData: undefined
+        });
+        if (this.timer) clearTimeout(this.timer);
+        if (onFilter) onFilter(text, from);
+        return;
+      }
+
+      if (onCreate) {
+        var innerData = this.handleCreate(text);
+        this.setState({
+          innerData: innerData
+        });
+      }
+
+      if (!onFilter) return;
+      this.setState({
+        filterText: text
+      });
+      if (this.timer) clearTimeout(this.timer);
+      this.timer = setTimeout(function () {
+        var fn = onFilter(text, from);
+
+        if (typeof fn === 'function') {
+          _this3.setState({
+            innerFilter: fn
+          });
+        }
+      }, filterDelay);
+    };
+
+    _proto.handleCreate = function handleCreate(text) {
+      var onCreate = this.props.onCreate;
+      var createFn = typeof onCreate === 'boolean' ? function (t) {
+        return t;
+      } : onCreate;
+      return createFn(text);
+    };
+
+    _proto.filterTreeData = function filterTreeData() {
+      var _this$props6 = this.props,
+          treeData = _this$props6.treeData,
+          expanded = _this$props6.expanded,
+          showHitDescendants = _this$props6.showHitDescendants,
+          onAdvancedFilter = _this$props6.onAdvancedFilter,
+          other = _objectWithoutPropertiesLoose(_this$props6, ["treeData", "expanded", "showHitDescendants", "onAdvancedFilter"]);
+
+      var innerFilter = this.state.innerFilter;
+      var filterExpandedKeys = expanded;
+      var newData = treeData;
+
+      if (innerFilter) {
+        filterExpandedKeys = [];
+        newData = getFilterTree(treeData, innerFilter, filterExpandedKeys, function (node) {
+          return getKey(node, other.keygen);
+        }, other.childrenKey, showHitDescendants, undefined, {
+          advanced: !!onAdvancedFilter
+        });
+      }
+
+      return {
+        treeData: newData,
+        expanded: filterExpandedKeys,
+        rawData: treeData
+      };
+    };
+
+    _proto.filterData = function filterData() {
+      var _this$props7 = this.props,
+          data = _this$props7.data,
+          hideCreateOption = _this$props7.hideCreateOption,
+          other = _objectWithoutPropertiesLoose(_this$props7, ["data", "hideCreateOption"]);
+
+      var _this$state = this.state,
+          innerFilter = _this$state.innerFilter,
+          innerData = _this$state.innerData;
+      var newData = data;
+      if (innerFilter) newData = data.filter(function (d) {
+        return innerFilter(d);
+      });
+
+      if (innerData && !hideCreateOption) {
+        var newKey = getKey(innerData, other.keygen, innerData);
+
+        if (!newData.find(function (d) {
+          return getKey(d, other.keygen, d) === newKey;
+        })) {
+          newData = [innerData].concat(newData);
+        }
+      }
+
+      return {
+        data: newData
+      };
+    };
+
+    _proto.render = function render() {
+      var _this$props8 = this.props,
+          treeData = _this$props8.treeData,
+          onFilter = _this$props8.onFilter,
+          onCreate = _this$props8.onCreate,
+          other = _objectWithoutPropertiesLoose(_this$props8, ["treeData", "onFilter", "onCreate"]);
+
+      var _this$state2 = this.state,
+          filterText = _this$state2.filterText,
+          innerData = _this$state2.innerData,
+          text = _this$state2.text;
+      var filterFn = onFilter || onCreate ? this.handleFilter : undefined;
+      var dataGenerator = treeData ? this.filterTreeData : this.filterData;
+
+      var props = _objectSpread({}, other, {
+        filterText: filterText,
+        inputText: text,
+        result: this.getResultByValues(),
+        inputable: !!onCreate,
+        onCreate: onCreate ? this.handleCreate : undefined,
+        onFilter: filterFn,
+        innerData: innerData
+      }, dataGenerator.call(this));
+
+      return React.createElement(Origin, props);
+    };
+
+    return Filter;
+  }(React.Component), _defineProperty(_class, "defaultProps", {
+    data: [],
+    filterDelay: 300,
+    showHitDescendants: false
+  }), _temp;
+});

package/esm/Select/group.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { SelectPropsWidthGroup, SelectPropsWidthAbsolute } from './Props';
+interface GroupState<Item> {
+    data: Item[];
+}
+declare const _default: <Item, Value>(Origin: React.ComponentType<import("./Props").BaseSelectProps<Item, Value>>) => {
+    new (props: SelectPropsWidthGroup<Item, Value>): {
+        groupKey: string;
+        componentDidMount(): void;
+        componentDidUpdate(prevProps: SelectPropsWidthGroup<Item, Value>): void;
+        groupByData(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "data">(state: GroupState<Item> | ((prevState: Readonly<GroupState<Item>>, props: Readonly<SelectPropsWidthGroup<Item, Value>>) => GroupState<Item> | Pick<GroupState<Item>, K> | null) | Pick<GroupState<Item>, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<SelectPropsWidthGroup<Item, Value>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<GroupState<Item>>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<SelectPropsWidthGroup<Item, Value>>, nextState: Readonly<GroupState<Item>>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<SelectPropsWidthGroup<Item, Value>>, prevState: Readonly<GroupState<Item>>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<SelectPropsWidthGroup<Item, Value>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<SelectPropsWidthGroup<Item, Value>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<SelectPropsWidthGroup<Item, Value>>, nextState: Readonly<GroupState<Item>>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<SelectPropsWidthGroup<Item, Value>>, nextState: Readonly<GroupState<Item>>, nextContext: any): void;
+    };
+    defaultProps: {
+        data: never[];
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/esm/Select/group.js

@@ -0,0 +1,86 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { getUidStr } from '../utils/uid';
+export default (function (Origin) {
+  var _class, _temp;
+
+  return _temp = _class =
+  /*#__PURE__*/
+  function (_React$Component) {
+    _inheritsLoose(Group, _React$Component);
+
+    function Group(props) {
+      var _this;
+
+      _this = _React$Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "groupKey", void 0);
+
+      _this.state = {
+        data: []
+      };
+      _this.groupByData = _this.groupByData.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.groupKey = getUidStr();
+      return _this;
+    }
+
+    var _proto = Group.prototype;
+
+    _proto.componentDidMount = function componentDidMount() {
+      this.groupByData();
+    };
+
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+      if (prevProps.data !== this.props.data) this.groupByData();
+    };
+
+    _proto.groupByData = function groupByData() {
+      var _this2 = this;
+
+      var _this$props = this.props,
+          groupBy = _this$props.groupBy,
+          data = _this$props.data;
+
+      if (typeof groupBy !== 'function') {
+        this.setState({
+          data: data
+        });
+        return;
+      }
+
+      var groupData = {};
+      data.forEach(function (d, i) {
+        var _ref;
+
+        var g = groupBy(d, i, data);
+        if (!groupData[g]) groupData[g || ''] = g ? [(_ref = {}, _ref[_this2.groupKey] = g, _ref)] : [];
+        groupData[g].push(d);
+      });
+      this.setState({
+        data: Object.keys(groupData).reduce(function (p, v) {
+          return v ? p.concat(groupData[v]) : groupData[v].concat(p);
+        }, [])
+      });
+    };
+
+    _proto.render = function render() {
+      var _this$props2 = this.props,
+          groupBy = _this$props2.groupBy,
+          data = _this$props2.data,
+          props = _objectWithoutPropertiesLoose(_this$props2, ["groupBy", "data"]);
+
+      return React.createElement(Origin, _extends({}, props, {
+        data: this.state.data,
+        groupKey: this.groupKey
+      }));
+    };
+
+    return Group;
+  }(React.Component), _defineProperty(_class, "defaultProps", {
+    data: []
+  }), _temp;
+});

package/esm/Select/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("./Props").SelectClass;
+export default _default;

package/esm/Select/index.js

@@ -0,0 +1,34 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import inputable from '../Form/inputable';
+import { compose } from '../utils/func';
+import Datum from '../Datum';
+import inputBorder from '../hoc/inputBorder';
+import { selectClass } from './styles';
+import tiled, { advancedFilterHOC } from '../TreeSelect/tiled';
+import Select from './Select';
+import filter from './filter';
+import group from './group';
+import absolute from '../Table/context';
+
+var limitWrap = function limitWrap(Origin) {
+  return function (props) {
+    // eslint-disable-next-line
+    var limit = props.multiple ? 0 : 1;
+    return React.createElement(Origin, _extends({}, props, {
+      limit: limit
+    }));
+  };
+};
+
+var exportSelect = compose(inputable, inputBorder({
+  className: selectClass('_'),
+  tag: 'div'
+}), limitWrap, Datum.hoc({
+  bindProps: ['disabled', 'limit', 'format', 'prediction', 'separator'],
+  pure: false
+}), advancedFilterHOC, filter, tiled({
+  dataKey: 'treeData'
+}), group, absolute)(Select);
+exportSelect.displayName = 'ShineoutSelect';
+export default exportSelect;

package/esm/Select/interface.d.ts

@@ -0,0 +1 @@
+export { SelectProps as Props } from './Props';

package/esm/Select/interface.js

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

package/esm/Select/styles/index.d.ts

@@ -0,0 +1 @@
+export const selectClass: (...args: any) => string;

package/esm/Select/styles/index.js

@@ -0,0 +1,4 @@
+import '../../styles/normalize.less';
+import selectLess from './select.less';
+import genaration from '../../utils/classname';
+export var selectClass = genaration(selectLess, 'select');