shineout 1.12.2 → 1.12.3

package/esm/Datum/Tree.js

@@ -0,0 +1,424 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { CHANGE_TOPIC } from './types';
+var IS_NOT_MATCHED_VALUE = 'IS_NOT_MATCHED_VALUE';
+export var CheckedMode = {
+  // 只返回全选数据，包含父节点和子节点
+  Full: 0,
+  // 返回全部选择字节点和部分选中的父节点
+  Half: 1,
+  // 只返回选中子节点
+  Child: 2,
+  // 如果父节点下所有子节点全部选中，只返回父节点
+  Shallow: 3,
+  // 所选即所得
+  Freedom: 4
+}; // check status stack
+
+var checkStatusStack = function checkStatusStack(stack, defaultStatus) {
+  if (!stack || stack.length <= 0) return defaultStatus;
+  if (stack.filter(function (d) {
+    return d === 0;
+  }).length === stack.length) return 0;
+  var s = stack.filter(function (d) {
+    return d === 0 || d === 2;
+  });
+  if (s.length <= 0) return defaultStatus;
+  return 2;
+};
+
+var _default =
+/*#__PURE__*/
+function () {
+  function _default(options) {
+    if (options === void 0) {
+      options = {
+        data: [],
+        childrenKey: ''
+      };
+    }
+
+    _defineProperty(this, "keygen", void 0);
+
+    _defineProperty(this, "mode", void 0);
+
+    _defineProperty(this, "unmatch", void 0);
+
+    _defineProperty(this, "disabled", void 0);
+
+    _defineProperty(this, "childrenKey", void 0);
+
+    _defineProperty(this, "valueMap", void 0);
+
+    _defineProperty(this, "unmatchedValueMap", void 0);
+
+    _defineProperty(this, "events", void 0);
+
+    _defineProperty(this, "$events", void 0);
+
+    _defineProperty(this, "value", void 0);
+
+    _defineProperty(this, "data", void 0);
+
+    _defineProperty(this, "cachedValue", void 0);
+
+    _defineProperty(this, "pathMap", void 0);
+
+    _defineProperty(this, "dataMap", void 0);
+
+    var _options = options,
+        data = _options.data,
+        value = _options.value,
+        keygen = _options.keygen,
+        mode = _options.mode,
+        disabled = _options.disabled,
+        _options$childrenKey = _options.childrenKey,
+        childrenKey = _options$childrenKey === void 0 ? 'children' : _options$childrenKey,
+        unmatch = _options.unmatch;
+    this.keygen = keygen;
+    this.mode = mode;
+    this.valueMap = new Map();
+    this.unmatchedValueMap = new Map();
+    this.unmatch = unmatch;
+    this.events = new Map();
+    this.$events = {};
+    this.childrenKey = childrenKey;
+    this.updateDisabled(disabled);
+    this.setValue(value);
+    this.setData(data);
+  }
+
+  var _proto = _default.prototype;
+
+  _proto.updateDisabled = function updateDisabled(dis) {
+    if (typeof dis === 'function') {
+      this.disabled = dis;
+    } else {
+      this.disabled = function () {
+        return !!dis;
+      };
+    }
+  };
+
+  _proto.bind = function bind(id, update) {
+    this.events.set(id, update);
+  };
+
+  _proto.unbind = function unbind(id) {
+    this.events.delete(id);
+  };
+
+  _proto.setUnmatedValue = function setUnmatedValue() {
+    var _this = this;
+
+    this.unmatchedValueMap = new Map();
+    if (!this.value || !this.data) return;
+    this.value.forEach(function (v) {
+      var data = _this.getDataById(v);
+
+      var unmatched = _this.isUnMatch(data);
+
+      if (unmatched) _this.unmatchedValueMap.set(v, true);else _this.unmatchedValueMap.delete(v);
+    });
+  } // eslint-disable-next-line class-methods-use-this
+  ;
+
+  _proto.isUnMatch = function isUnMatch(data) {
+    return data && data[IS_NOT_MATCHED_VALUE];
+  };
+
+  _proto.setValue = function setValue(value) {
+    this.value = value;
+
+    if (value && value !== this.cachedValue) {
+      this.initValue();
+    }
+
+    this.setUnmatedValue();
+  };
+
+  _proto.getValue = function getValue() {
+    var _this2 = this;
+
+    var value = [];
+    this.valueMap.forEach(function (checked, id) {
+      switch (_this2.mode) {
+        case CheckedMode.Full:
+        case CheckedMode.Freedom:
+          if (checked === 1) value.push(id);
+          break;
+
+        case CheckedMode.Half:
+          if (checked >= 1) value.push(id);
+          break;
+
+        case CheckedMode.Child:
+          if (checked === 1) {
+            var info = _this2.pathMap.get(id);
+
+            if (info && info.children.length === 0) value.push(id);
+          }
+
+          break;
+
+        case CheckedMode.Shallow:
+          if (checked === 1) {
+            var parentChecked = function () {
+              var info = _this2.pathMap.get(id);
+
+              if (!info) return false;
+              var path = info.path;
+              var pid = path[path.length - 1];
+              if (!pid && pid !== 0) return false;
+              return _this2.valueMap.get(pid) === 1;
+            }();
+
+            if (!parentChecked) value.push(id);
+          }
+
+          break;
+
+        default:
+      }
+    });
+    this.unmatchedValueMap.forEach(function (unmatch, id) {
+      if (unmatch && _this2.unmatch) value.push(id);
+    });
+    this.cachedValue = value;
+    return value;
+  };
+
+  _proto.setValueMap = function setValueMap(id, checked) {
+    this.valueMap.set(id, checked);
+    var update = this.events.get(id);
+    if (update) update();
+  };
+
+  _proto.set = function set(id, checked, direction) {
+    var _this3 = this;
+
+    // self
+    if (!this.isDisabled(id)) this.setValueMap(id, checked);
+    var data = this.getDataById(id);
+
+    if (data && data[IS_NOT_MATCHED_VALUE]) {
+      if (checked) this.unmatchedValueMap.set(id, true);else this.unmatchedValueMap.delete(id);
+      return null;
+    }
+
+    if (CheckedMode.Freedom === this.mode) {
+      // Free mode will return zero
+      return 0;
+    }
+
+    var _this$pathMap$get = this.pathMap.get(id),
+        path = _this$pathMap$get.path,
+        children = _this$pathMap$get.children;
+
+    var childrenStack = []; // children
+
+    if (direction !== 'asc') {
+      children.forEach(function (cid) {
+        // push status to stack
+        childrenStack.push(_this3.set(cid, checked, 'desc'));
+      });
+    } // Exclude disabled
+
+
+    var current = this.valueMap.get(id); // check all children status
+
+    var status = checkStatusStack(childrenStack, current);
+
+    if (status !== current) {
+      this.setValueMap(id, status);
+      current = status;
+    } // parent
+
+
+    if (direction !== 'desc' && path.length > 0) {
+      var parentId = path[path.length - 1];
+      var parentChecked = current;
+      this.pathMap.get(parentId).children.forEach(function (cid) {
+        if (parentChecked !== _this3.valueMap.get(cid)) {
+          parentChecked = 2;
+        }
+      });
+      this.set(parentId, parentChecked, 'asc');
+    }
+
+    return current;
+  };
+
+  _proto.isDisabled = function isDisabled(id) {
+    var node = this.pathMap.get(id);
+    if (node) return node.isDisabled;
+    return false;
+  };
+
+  _proto.get = function get(id) {
+    return this.valueMap.get(id);
+  };
+
+  _proto.getDataById = function getDataById(id) {
+    var _ref;
+
+    var oroginData = this.dataMap.get(id);
+    if (oroginData) return oroginData;
+    if (!this.unmatch) return null;
+    return _ref = {}, _ref[IS_NOT_MATCHED_VALUE] = true, _ref.value = id, _ref;
+  };
+
+  _proto.getPath = function getPath(id) {
+    return this.pathMap.get(id);
+  };
+
+  _proto.getChecked = function getChecked(id) {
+    var value = this.get(id);
+    var checked = value === 1;
+    if (value === 2) checked = 'indeterminate';
+    return checked;
+  };
+
+  _proto.getKey = function getKey(data, id, index) {
+    if (id === void 0) {
+      id = '';
+    }
+
+    if (typeof this.keygen === 'function') return this.keygen(data, id);
+    if (this.keygen) return data[this.keygen];
+    return id + (id ? ',' : '') + index;
+  };
+
+  _proto.initValue = function initValue(ids, forceCheck) {
+    var _this4 = this;
+
+    if (!this.data || !this.value) return undefined;
+
+    if (!ids) {
+      ids = [];
+      this.pathMap.forEach(function (val, id) {
+        if (val.path.length === 0) ids.push(id);
+      });
+    }
+
+    var checked = 0;
+    ids.forEach(function (id) {
+      var _this4$pathMap$get = _this4.pathMap.get(id),
+          children = _this4$pathMap$get.children;
+
+      if (forceCheck) {
+        _this4.setValueMap(id, 1);
+
+        _this4.initValue(children, forceCheck);
+
+        return;
+      }
+
+      var childChecked = _this4.value.indexOf(id) >= 0 ? 1 : 0;
+
+      if (childChecked === 1 && _this4.mode !== CheckedMode.Half && _this4.mode !== CheckedMode.Freedom) {
+        _this4.initValue(children, true);
+      } else if (children.length > 0) {
+        // 保持迭代
+        var res = _this4.initValue(children);
+
+        childChecked = _this4.mode === CheckedMode.Freedom ? childChecked : res;
+      } else {
+        childChecked = _this4.value.indexOf(id) >= 0 ? 1 : 0;
+      }
+
+      _this4.setValueMap(id, childChecked);
+
+      if (checked === undefined) checked = childChecked;else if (checked !== childChecked) checked = 2;
+    });
+    return checked;
+  };
+
+  _proto.initData = function initData(data, path, disabled, index) {
+    var _this5 = this;
+
+    if (index === void 0) {
+      index = [];
+    }
+
+    var ids = [];
+    data.forEach(function (d, i) {
+      var id = _this5.getKey(d, path[path.length - 1], i);
+
+      if (_this5.dataMap.get(id)) {
+        console.error("There is already a key \"" + id + "\" exists. The key must be unique.");
+        return;
+      }
+
+      _this5.dataMap.set(id, d);
+
+      var isDisabled = !!disabled;
+
+      if (!isDisabled && typeof _this5.disabled === 'function') {
+        isDisabled = _this5.disabled(d, i);
+      }
+
+      var indexPath = [].concat(index, [i]);
+      ids.push(id);
+      var children = [];
+
+      if (Array.isArray(d[_this5.childrenKey])) {
+        children = _this5.initData(d[_this5.childrenKey], [].concat(path, [id]), // exclude Freedom
+        _this5.mode === CheckedMode.Freedom ? disabled : isDisabled, indexPath);
+      }
+
+      _this5.pathMap.set(id, {
+        children: children,
+        path: path,
+        isDisabled: isDisabled,
+        indexPath: indexPath,
+        index: i
+      });
+    });
+    return ids;
+  };
+
+  _proto.setData = function setData(data, dispatch) {
+    var prevValue = this.value || [];
+    this.cachedValue = [];
+    this.pathMap = new Map();
+    this.dataMap = new Map();
+    this.valueMap = new Map();
+    this.unmatchedValueMap = new Map();
+    this.data = data;
+    if (!data) return;
+    this.initData(data, []);
+    this.initValue();
+    this.setValue(prevValue);
+    if (dispatch) this.dispatch(CHANGE_TOPIC);
+  };
+
+  _proto.subscribe = function subscribe(name, fn) {
+    if (!this.$events[name]) this.$events[name] = [];
+    var events = this.$events[name];
+    if (events.includes(fn)) return;
+    events.push(fn);
+  };
+
+  _proto.unsubscribe = function unsubscribe(name, fn) {
+    if (!this.$events[name]) return;
+    this.$events[name] = this.$events[name].filter(function (e) {
+      return e !== fn;
+    });
+  };
+
+  _proto.dispatch = function dispatch(name) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    var event = this.$events[name];
+    if (!event) return;
+    event.forEach(function (fn) {
+      return fn.apply(void 0, args);
+    });
+  };
+
+  return _default;
+}();
+
+export { _default as default };

package/esm/Datum/hoc.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/esm/Datum/hoc.js

@@ -0,0 +1,133 @@
+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 { curry } from '../utils/func';
+import { capitalize } from '../utils/strings';
+import { IGNORE_VALIDATE, WITH_OUT_DISPATCH } from './types';
+import List from './List';
+import Form from './Form';
+var types = {
+  form: Form,
+  list: List
+};
+export default curry(function (options, Origin) {
+  var _class, _temp;
+
+  var _ref = options || {},
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? 'list' : _ref$type,
+      _ref$key = _ref.key,
+      key = _ref$key === void 0 ? 'value' : _ref$key,
+      _ref$limit = _ref.limit,
+      limit = _ref$limit === void 0 ? 0 : _ref$limit,
+      _ref$bindProps = _ref.bindProps,
+      bindProps = _ref$bindProps === void 0 ? [] : _ref$bindProps,
+      ignoreUndefined = _ref.ignoreUndefined,
+      _ref$pure = _ref.pure,
+      pure = _ref$pure === void 0 ? true : _ref$pure;
+
+  var Datum = types[type];
+  var Component = pure ? React.PureComponent : React.Component;
+  return _temp = _class =
+  /*#__PURE__*/
+  function (_Component) {
+    _inheritsLoose(_class, _Component);
+
+    function _class(props) {
+      var _this;
+
+      _this = _Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "datum", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "prevValues", void 0);
+
+      var datum = props.datum,
+          onChange = props.onChange,
+          initValidate = props.initValidate;
+
+      if (datum instanceof Datum) {
+        _this.datum = datum;
+      } else {
+        var ops = bindProps.reduce(function (o, k) {
+          o[k] = props[k];
+          return o;
+        }, {
+          limit: limit,
+          initValidate: initValidate
+        });
+
+        if (key in props) {
+          ops[key] = props[key];
+        }
+
+        if ("default" + capitalize(key) in props) {
+          ops["default" + capitalize(key)] = props["default" + capitalize(key)];
+        }
+
+        _this.datum = new Datum(Object.assign(ops, datum));
+      }
+
+      if (onChange) {
+        _this.datum.onChange = onChange;
+      }
+
+      return _this;
+    }
+
+    var _proto = _class.prototype;
+
+    _proto.componentDidMount = function componentDidMount() {
+      this.datum.setLock(false);
+      this.prevValues = this.props[key];
+    };
+
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+      // update datum.onchange
+      this.datum.setLock(false);
+
+      if (prevProps.onChange !== this.props.onChange) {
+        this.datum.onChange = this.props.onChange;
+      }
+    };
+
+    _proto.setValue = function setValue(t) {
+      var values = this.props[key];
+      if (ignoreUndefined && values === undefined) return;
+      this.datum.setValue(values, t);
+    };
+
+    _proto.render = function render() {
+      var _this$props = this.props,
+          onDatumBind = _this$props.onDatumBind,
+          props = _objectWithoutPropertiesLoose(_this$props, ["onDatumBind"]);
+
+      if (onDatumBind) onDatumBind(this.datum);
+
+      if (bindProps.includes('disabled')) {
+        this.datum.setDisabled(props.disabled);
+      }
+
+      var values = this.props[key];
+
+      if (type === 'form' && values !== this.prevValues) {
+        this.setValue(this.props.initValidate ? undefined : IGNORE_VALIDATE);
+        this.datum.setLock(true);
+        this.prevValues = values;
+      }
+
+      if (type === 'list') this.setValue(WITH_OUT_DISPATCH); // delete props[key]
+
+      return React.createElement(Origin, _extends({}, props, {
+        datum: this.datum
+      }));
+    };
+
+    return _class;
+  }(Component), _defineProperty(_class, "defaultProps", {
+    initValidate: false
+  }), _temp;
+});

package/esm/Datum/index.d.ts

@@ -0,0 +1,8 @@
+import Form from './Form';
+import List from './List';
+declare const _default: {
+    Form: typeof Form;
+    List: typeof List;
+    hoc: any;
+};
+export default _default;

package/esm/Datum/index.js

@@ -0,0 +1,8 @@
+import Form from './Form';
+import List from './List';
+import hoc from './hoc';
+export default {
+  Form: Form,
+  List: List,
+  hoc: hoc
+};

package/esm/Datum/types.d.ts

@@ -0,0 +1,16 @@
+export declare const changeSubscribe: (name: string) => string;
+export declare const errorSubscribe: (name: string) => string;
+export declare const updateSubscribe: (name: string) => string;
+export declare const CHANGE_TOPIC = "__CHANGE_TOPIC__";
+export declare const VALIDATE_TOPIC = "__VALIDATE_TOPIC__";
+export declare const RESET_TOPIC = "__RESET_TOPIC__";
+export declare const FORCE_PASS = "__VALIDATE_FORCE_PASS__";
+export declare const IGNORE_VALIDATE = "__IGNORE_VALIDATE__";
+export declare const ERROR_TYPE = "__UPDATE_ERROR_TYPE__";
+export declare const REMOVE_ERROR = "__REMOVE_ERROR_TYPE__";
+export declare const WITH_OUT_DISPATCH = "__WITH_OUT_DISPATCH__";
+export declare const IGNORE_BIND = "__IGNORE_BIND__";
+export declare const SUBMIT_TOPIC = "__SUBMIT_TOPIC__";
+export declare type ValidType = typeof IGNORE_BIND | typeof FORCE_PASS;
+export declare type PublishType = typeof FORCE_PASS | typeof IGNORE_VALIDATE;
+export declare type ChangeType = typeof WITH_OUT_DISPATCH;

package/esm/Datum/types.js

@@ -0,0 +1,22 @@
+// FLow chagne
+export var changeSubscribe = function changeSubscribe(name) {
+  return "__CHANGE_SUBSCRIBE_" + name + "__";
+}; // setError
+
+export var errorSubscribe = function errorSubscribe(name) {
+  return "__ERROR_SUBSCRIBE_" + name + "__";
+}; // value chagne
+
+export var updateSubscribe = function updateSubscribe(name) {
+  return "__UPDATE_SUBSCRIBE_" + name + "__";
+};
+export var CHANGE_TOPIC = '__CHANGE_TOPIC__';
+export var VALIDATE_TOPIC = '__VALIDATE_TOPIC__';
+export var RESET_TOPIC = '__RESET_TOPIC__';
+export var FORCE_PASS = '__VALIDATE_FORCE_PASS__';
+export var IGNORE_VALIDATE = '__IGNORE_VALIDATE__';
+export var ERROR_TYPE = '__UPDATE_ERROR_TYPE__';
+export var REMOVE_ERROR = '__REMOVE_ERROR_TYPE__';
+export var WITH_OUT_DISPATCH = '__WITH_OUT_DISPATCH__';
+export var IGNORE_BIND = '__IGNORE_BIND__';
+export var SUBMIT_TOPIC = '__SUBMIT_TOPIC__';

package/esm/Divider/Props.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { StandardProps } from '../@types/common';
+declare type ReactNode = React.ReactNode;
+export interface DividerProps extends StandardProps {
+    /**
+     * desc: Content, text or react component
+     *
+     * 分割线中文字内容
+     *
+     * default: -
+     */
+    children?: ReactNode;
+    /**
+     * desc: mode of divider
+     *
+     * 分割线排布模式
+     *
+     * default: *horizontal*
+     */
+    mode?: 'horizontal' | 'vertical';
+    /**
+     * desc: The position of title inside divider
+     *
+     * 水平分割线的文字排布位置
+     *
+     * default: *center*
+     */
+    orientation?: 'center' | 'left' | 'right';
+}
+export {};

package/esm/Divider/Props.js

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

package/esm/Divider/index.d.ts

@@ -0,0 +1,10 @@
+import { PureComponent } from 'react';
+import { DividerProps } from './Props';
+declare class Divider extends PureComponent<DividerProps> {
+    static defaultProps: {
+        mode: string;
+    };
+    showText(): boolean | "" | 0 | null | undefined;
+    render(): JSX.Element;
+}
+export default Divider;