shineout 1.12.2 → 1.12.3

package/esm/Datum/List.d.ts

@@ -0,0 +1,47 @@
+import { ChangeType } from './types';
+import { ObjectType } from '../@types/common';
+import { ListDatumOptions } from './Props';
+export default class<Item, Value> {
+    distinct: ListDatumOptions<Item, Value>['distinct'];
+    prediction: ListDatumOptions<Item, Value>['prediction'];
+    onChange: ListDatumOptions<Item, Value>['onChange'];
+    limit: ListDatumOptions<Item, Value>['limit'];
+    separator?: ListDatumOptions<Item, Value>['separator'];
+    $events: ObjectType<Function[]>;
+    $cachedDisabled: ListDatumOptions<Item, Value>['disabled'] | {};
+    $cachedFlatten: Map<any, any>;
+    valueMap: Map<any, boolean>;
+    disabled: (...args: any) => boolean;
+    format: (...args: any) => unknown;
+    $values: any[];
+    $cachedValue: Value;
+    updateLock: boolean;
+    constructor(args?: ListDatumOptions<Item, Value>);
+    get length(): number;
+    cleanDataCache(): void;
+    get values(): any[];
+    set values(values: any[]);
+    resetValueMap(): void;
+    setDisabled(disabled: ListDatumOptions<Item, Value>['disabled']): void;
+    handleChange(values: any[], ...args: any): void;
+    flattenTreeData(data: Item[], childrenKey: keyof Item): any;
+    setLock(lock: boolean): void;
+    add(data: Item | Item[], _?: any, childrenKey?: keyof Item, unshift?: boolean): void;
+    set(value: Item): void;
+    check(raw: Item): boolean;
+    getDataByValue(data: Item[], value: Value extends (infer U)[] ? U : Value): Item | null | undefined;
+    clear(): void;
+    dispatch(name: string, ...args: any): void;
+    initFormat(f: ListDatumOptions<Item, Value>['format']): void;
+    defaultPrediction(value: unknown, data: Item): boolean;
+    remove(value: Item | Item[] | {
+        IS_NOT_MATCHED_VALUE: boolean;
+        value: any;
+    }, _?: unknown, childrenKey?: string): void;
+    subscribe(name: string, fn: Function): void;
+    unsubscribe(name: string, fn: Function): void;
+    getValue(): any;
+    resetValue(values: any[], cached: boolean): void;
+    formatValue(values: Value | undefined): string[] | (Value | undefined)[] | (Value & any[]);
+    setValue(values?: Value, type?: ChangeType): void;
+}

package/esm/Datum/List.js

@@ -0,0 +1,441 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import deepEqual from 'deep-eql';
+import shallowEqual from '../utils/shallowEqual';
+import { CHANGE_TOPIC, WITH_OUT_DISPATCH } from './types';
+
+var _default =
+/*#__PURE__*/
+function () {
+  function _default(args) {
+    if (args === void 0) {
+      args = {};
+    }
+
+    _defineProperty(this, "distinct", void 0);
+
+    _defineProperty(this, "prediction", void 0);
+
+    _defineProperty(this, "onChange", void 0);
+
+    _defineProperty(this, "limit", void 0);
+
+    _defineProperty(this, "separator", void 0);
+
+    _defineProperty(this, "$events", void 0);
+
+    _defineProperty(this, "$cachedDisabled", void 0);
+
+    _defineProperty(this, "$cachedFlatten", void 0);
+
+    _defineProperty(this, "valueMap", void 0);
+
+    _defineProperty(this, "disabled", void 0);
+
+    _defineProperty(this, "format", void 0);
+
+    _defineProperty(this, "$values", void 0);
+
+    _defineProperty(this, "$cachedValue", void 0);
+
+    _defineProperty(this, "updateLock", void 0);
+
+    var _args = args,
+        format = _args.format,
+        onChange = _args.onChange,
+        separator = _args.separator,
+        value = _args.value,
+        prediction = _args.prediction,
+        distinct = _args.distinct,
+        disabled = _args.disabled,
+        limit = _args.limit;
+    this.distinct = distinct;
+    this.limit = limit;
+    this.separator = separator;
+    this.initFormat(format);
+    this.$events = {};
+    this.$cachedDisabled = {};
+    this.$cachedFlatten = new Map();
+    this.setDisabled(disabled);
+    if (prediction) this.prediction = prediction;
+    this.setValue(value, WITH_OUT_DISPATCH);
+    this.onChange = onChange;
+  }
+
+  var _proto = _default.prototype;
+
+  // should clean $cachedFlatten when data changed
+  _proto.cleanDataCache = function cleanDataCache() {
+    this.$cachedFlatten = new Map();
+  };
+
+  _proto.resetValueMap = function resetValueMap() {
+    var map = new Map();
+
+    for (var i = 0; i < this.$values.length; i++) {
+      map.set(this.$values[i], true);
+    }
+
+    this.valueMap = map;
+  };
+
+  _proto.setDisabled = function setDisabled(disabled) {
+    if (this.$cachedDisabled === disabled) return;
+    this.$cachedDisabled = disabled;
+
+    this.disabled = function (data) {
+      switch (typeof disabled) {
+        case 'boolean':
+          return disabled;
+
+        case 'function':
+          for (var _len = arguments.length, obj = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            obj[_key - 1] = arguments[_key];
+          }
+
+          return disabled.apply(void 0, [data].concat(obj));
+
+        default:
+          return false;
+      }
+    };
+  };
+
+  _proto.handleChange = function handleChange(values) {
+    this.$values = values;
+    this.resetValueMap();
+    this.dispatch(CHANGE_TOPIC);
+
+    if (this.onChange) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      this.onChange.apply(this, [this.getValue()].concat(args));
+    }
+  };
+
+  _proto.flattenTreeData = function flattenTreeData(data, childrenKey) {
+    var _this = this;
+
+    var keys = data.map(function (v) {
+      return _this.format(v);
+    }).map(function (v) {
+      return typeof v === 'object' ? JSON.stringify(v) : v;
+    });
+    var key = keys.join();
+
+    if (keys.length !== 0) {
+      var cached = this.$cachedFlatten.get(key);
+      if (cached) return cached;
+    }
+
+    var flatten = [];
+
+    var deepAdd = function deepAdd(items) {
+      items.forEach(function (item) {
+        var exist = flatten.find(function (raw) {
+          return _this.prediction ? _this.prediction(raw, item) : _this.format(raw) === _this.format(item);
+        });
+        if (!exist) flatten.push(item);
+        if (item[childrenKey]) deepAdd(item[childrenKey]);
+      });
+    };
+
+    deepAdd(data);
+    if (keys.length) this.$cachedFlatten.set(key, flatten);
+    return flatten;
+  };
+
+  _proto.setLock = function setLock(lock) {
+    this.updateLock = lock;
+  };
+
+  _proto.add = function add(data, _, childrenKey, unshift) {
+    var _this2 = this;
+
+    if (data === undefined || data === null) return; // clear value
+
+    if (this.limit === 1) this.$values = [];
+    this.resetValueMap();
+    var raws = Array.isArray(data) ? data : [data];
+
+    if (childrenKey && this.limit !== 1) {
+      raws = this.flattenTreeData(raws, childrenKey);
+    }
+
+    raws = raws.filter(function (v) {
+      var disabled = _this2.disabled(v);
+
+      if (disabled) return false;
+      if (_this2.distinct) return !_this2.check(v);
+      return true;
+    });
+    var values = [];
+
+    for (var _iterator = raws, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var r = _ref;
+      var v = this.format(r);
+      if (v !== undefined) values.push(v);
+    }
+
+    this.handleChange(unshift ? values.concat(this.values) : this.values.concat(values), data, true);
+  };
+
+  _proto.set = function set(value) {
+    this.$values = [];
+    this.resetValueMap();
+    this.add(value);
+  };
+
+  _proto.check = function check(raw) {
+    if (this.prediction) {
+      for (var i = 0, count = this.values.length; i < count; i++) {
+        if (this.prediction(this.values[i], raw)) return true;
+      }
+
+      return false;
+    }
+
+    return !!this.valueMap.get(this.format(raw));
+  };
+
+  _proto.getDataByValue = function getDataByValue(data, value) {
+    var _this3 = this;
+
+    if (this.prediction) {
+      for (var i = 0, count = data.length; i < count; i++) {
+        if (this.prediction(value, data[i])) return data[i];
+      }
+
+      return null;
+    }
+
+    return data.find(function (d) {
+      return value === _this3.format(d);
+    });
+  };
+
+  _proto.clear = function clear() {
+    this.values = [];
+  };
+
+  _proto.dispatch = function dispatch(name) {
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+
+    var event = this.$events[name];
+    if (!event) return;
+    event.forEach(function (fn) {
+      return fn.apply(void 0, args);
+    });
+  };
+
+  _proto.initFormat = function initFormat(f) {
+    switch (typeof f) {
+      case 'string':
+        this.format = function (value) {
+          return value[f];
+        };
+
+        break;
+
+      case 'function':
+        this.format = function (value) {
+          return f(value);
+        };
+
+        break;
+
+      default:
+        this.format = function (a) {
+          return a;
+        };
+
+        break;
+    }
+  };
+
+  _proto.defaultPrediction = function defaultPrediction(value, data) {
+    return value === this.format(data);
+  };
+
+  _proto.remove = function remove(value, _, childrenKey) {
+    var _this4 = this;
+
+    if (value === undefined || value === null) return;
+    var raws = Array.isArray(value) ? value : [value];
+
+    if (childrenKey) {
+      raws = this.flattenTreeData(raws, childrenKey);
+    }
+
+    raws = raws.filter(function (r) {
+      return !_this4.disabled(r);
+    });
+    var values = [];
+
+    if (!this.prediction) {
+      var rowValueMap = new Map();
+
+      for (var i = 0; i < raws.length; i++) {
+        if (raws[i].IS_NOT_MATCHED_VALUE) {
+          rowValueMap.set(raws[i].value, true);
+        } else {
+          rowValueMap.set(this.format(raws[i]), true);
+        }
+      }
+
+      for (var _i2 = 0; _i2 < this.values.length; _i2++) {
+        var val = this.values[_i2];
+
+        if (!rowValueMap.get(val)) {
+          values.push(val);
+        }
+      }
+    } else {
+      var prediction = this.prediction;
+
+      outer: for (var _iterator2 = this.values, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+          if (_i3 >= _iterator2.length) break;
+          _ref2 = _iterator2[_i3++];
+        } else {
+          _i3 = _iterator2.next();
+          if (_i3.done) break;
+          _ref2 = _i3.value;
+        }
+
+        var _val = _ref2;
+
+        for (var j = 0; j < raws.length; j++) {
+          if (raws[j].IS_NOT_MATCHED_VALUE && _val === raws[j].value || prediction(_val, raws[j])) {
+            raws.splice(j, 1);
+            continue outer;
+          }
+        }
+
+        values.push(_val);
+      }
+    } // this.values = values
+
+
+    this.handleChange(values, value, false);
+  };
+
+  _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.getValue = function getValue() {
+    var value = this.values; // eslint-disable-next-line
+
+    if (this.limit === 1) value = this.values[0];else if (this.separator) value = this.values.join(this.separator);
+    this.$cachedValue = value;
+    return value;
+  };
+
+  _proto.resetValue = function resetValue(values, cached) {
+    this.$values = values;
+    this.resetValueMap();
+
+    if (this.onChange && !cached) {
+      this.onChange(this.getValue());
+    }
+
+    this.dispatch(CHANGE_TOPIC);
+    this.dispatch('set-value');
+  };
+
+  _proto.formatValue = function formatValue(values) {
+    if (this.limit === 1 && !Array.isArray(values)) {
+      return [values];
+    }
+
+    if (!values) return [];
+
+    if (Array.isArray(values)) {
+      return values;
+    }
+
+    if (typeof values === 'string') {
+      if (this.separator) {
+        return values.split(this.separator).map(function (s) {
+          return s.trim();
+        });
+      }
+
+      console.warn('Select separator parameter is empty.');
+      return [values];
+    }
+
+    console.error(new Error('Select values is not valid.'));
+    return [];
+  };
+
+  _proto.setValue = function setValue(values, type) {
+    if (values === void 0) {
+      values = [];
+    }
+
+    if (deepEqual(values, this.$values)) return;
+
+    if (type === WITH_OUT_DISPATCH) {
+      this.$values = this.formatValue(values);
+      this.resetValueMap();
+    } else {
+      this.resetValue(this.formatValue(values), shallowEqual(this.$cachedValue, values, {}));
+    }
+
+    this.$cachedValue = this.getValue();
+  };
+
+  _createClass(_default, [{
+    key: "length",
+    get: function get() {
+      return this.$values.length;
+    }
+  }, {
+    key: "values",
+    get: function get() {
+      return this.$values;
+    },
+    set: function set(values) {
+      this.$values = values;
+      this.resetValueMap();
+      this.dispatch(CHANGE_TOPIC);
+
+      if (this.onChange) {
+        this.onChange(this.getValue());
+      }
+    }
+  }]);
+
+  return _default;
+}();
+
+export { _default as default };

package/esm/Datum/Props.d.ts

@@ -0,0 +1,89 @@
+import { FormItemRule } from '../Rule/Props';
+import { ForceAdd, LiteralUnion, ObjectType } from '../@types/common';
+import { ValidType } from './types';
+interface RuleObject {
+    [name: string]: FormItemRule<any> | RuleObject;
+}
+export interface FormValid {
+    (v: any, formValue: ObjectType, type?: ValidType): Promise<any>;
+    (type?: ValidType): Promise<any>;
+}
+export interface FormDatumOptions<V extends {}> {
+    /**
+     * When removeUndefined is true, remove undefined value on submit.
+     *
+     * 是否删除值为 undefined 的字段，默认值为删除
+     *
+     * default: true
+     */
+    removeUndefined?: boolean;
+    rules?: RuleObject;
+    onChange?: (value: V) => void;
+    value?: V;
+    error?: {
+        [name: string]: string | Error;
+    };
+    initValidate?: boolean;
+    defaultValue?: V;
+}
+export interface ListDatumOptions<Item, Value> {
+    value?: Value;
+    onChange?: (value: Value, data?: Item, checked?: boolean) => void;
+    /**
+     * set with multiple, value will separator by this
+     *
+     * 多选情况下设置后，value 会处理为 separator 分隔的字符串。
+     *
+     * default: none
+     */
+    separator?: string;
+    limit?: number;
+    distinct?: boolean;
+    /**
+     * By default, the result of the format function is used to compare whether it matches. In some cases (for example, whe an object that returns the original data is updated, an different option with the same value  is generated), the prediction function needs to be used to determine whether match
+     *
+     * (val, d) => val===format(d) | 默认使用 format 函数执行的结果来比较是否匹配，在某些情况下（例如返回原始数据的对象，更新数据时，生成了一个值相同，非同一个对象的选项），需要借助 prediction 函数来判断是否匹配
+     *
+     * default: (val, d) => val===format(d)
+     */
+    prediction?: (value: Value extends (infer U)[] ? U : Value, data: Item) => boolean;
+    /**
+     * When the value is true, disabled all checkboxes; When the value is function, disable the checkbox that this function returns true.
+     *
+     * 如果 disabled 为 true，禁用全部选项，如果 disabled 为函数，根据函数反回结果禁用选项
+     *
+     * default: false
+     */
+    disabled?: ((data: Item, ...rest: any) => boolean) | boolean;
+    /**
+     * Format value. The defaule value is return the original data. When it is a string, the value is fetched from the original data as a key equivalent to (d) => d[format] When it is a function, use its return value.
+     *
+     * 格式化 value。 默认值，返回原始数据。 为string时，会作为key从原始数据中获取值，相当于 (d) => d[format]。为函数时，以函数返回结果作为 value。
+     *
+     * default: d => d
+     */
+    format?: LiteralUnion<Item> | ((data: Item) => Value extends (infer U)[] ? U : Value);
+}
+export interface DatumHocOptions<Props> {
+    type: 'list' | 'form';
+    key: keyof Props & string;
+    limit: number;
+    bindProps: (keyof Props)[];
+    ignoreUndefined: boolean;
+    pure: boolean;
+}
+export interface DatumBaseProps {
+    onChange?: unknown;
+    datum?: unknown;
+    disabled?: unknown;
+}
+export interface DatumAddProps {
+    onDatumBind?: (datum: ObjectType) => void;
+    datum?: ObjectType;
+}
+export declare type GetDatumProps<U> = DatumAddProps & {
+    initValidate?: boolean;
+} & Omit<U, keyof DatumAddProps>;
+export declare type GetDatumListProps<U, DataItem, Value, Keys extends keyof ListDatumOptions<DataItem, Value>> = DatumAddProps & Omit<ForceAdd<U, Pick<ListDatumOptions<DataItem, Value>, Keys | 'onChange' | 'value'>>, keyof DatumAddProps>;
+export declare type GetDatumFormProps<U, Value, Keys extends keyof FormDatumOptions<Value>> = DatumAddProps & Omit<ForceAdd<U, Pick<FormDatumOptions<Value>, Keys | 'onChange' | 'value' | 'initValidate' | 'defaultValue'>>, keyof DatumAddProps>;
+export {};

package/esm/Datum/Props.js

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

package/esm/Datum/Tree.d.ts

@@ -0,0 +1,78 @@
+import { KeygenResult, ObjectType, KeygenType, UnMatchedValue } from '../@types/common';
+export declare const CheckedMode: {
+    Full: number;
+    Half: number;
+    Child: number;
+    Shallow: number;
+    Freedom: number;
+};
+declare type CheckedStatus = 0 | 1 | 2;
+export declare type TreeModeType = 0 | 1 | 2 | 3 | 4;
+export interface TreePathType {
+    children: KeygenResult[];
+    path: (number | string)[];
+    isDisabled: boolean;
+    indexPath: number[];
+    index: number;
+}
+declare type Value = KeygenResult[];
+export interface TreeDatumOptions<Item> {
+    data?: Item[];
+    keygen?: KeygenType<Item> | ((data: Item, parentKey: KeygenResult) => KeygenResult);
+    value?: Value;
+    /**
+     * mode 0: Returns only the fully selected node including the parent node. 1: Returns all selected nodes and semi-selected nodes. 2: Return only the selected child nodes. 3: If the parent node is full selected, only return the parent node. 4: What you choose is what you get.
+     *
+     * 选中值模式，未设置值为单选 0: 只返回完全选中的节点，包含父节点 1: 返回全部选中的节点和半选中的父节点 2: 只返回选中的子节点 3: 如果父节点选中，只返回父节点 4: 所选即所得
+     *
+     * default: -
+     */
+    mode?: TreeModeType;
+    disabled?: ((data: Item, ...rest: any) => boolean) | boolean;
+    childrenKey: string;
+    unmatch?: boolean;
+    loader?: (key: KeygenResult, data: Item) => void;
+    onChange?: (value: any, ...rest: any) => void;
+}
+export default class<Item> {
+    keygen?: TreeDatumOptions<Item>['keygen'];
+    mode: TreeDatumOptions<Item>['mode'];
+    unmatch: TreeDatumOptions<Item>['unmatch'];
+    disabled: ((data: Item, ...rest: any) => boolean);
+    childrenKey: TreeDatumOptions<Item>['childrenKey'];
+    valueMap: Map<KeygenResult, CheckedStatus>;
+    unmatchedValueMap: Map<any, any>;
+    events: Map<KeygenResult, Function>;
+    $events: ObjectType<Function[]>;
+    value?: Value;
+    data?: Item[];
+    cachedValue?: unknown[];
+    pathMap: Map<KeygenResult, TreePathType>;
+    dataMap: Map<KeygenResult, Item>;
+    constructor(options?: TreeDatumOptions<Item>);
+    updateDisabled(dis: TreeDatumOptions<Item>['disabled']): void;
+    bind(id: number | string, update: Function): void;
+    unbind(id: KeygenResult): void;
+    setUnmatedValue(): void;
+    isUnMatch(data: ObjectType | null): data is UnMatchedValue;
+    setValue(value?: Value): void;
+    getValue(): Value;
+    setValueMap(id: KeygenResult, checked: CheckedStatus): void;
+    set(id: KeygenResult, checked: CheckedStatus, direction?: 'asc' | 'desc'): CheckedStatus | null;
+    isDisabled(id: KeygenResult): boolean;
+    get(id: KeygenResult): CheckedStatus | undefined;
+    getDataById(id: KeygenResult): Item | {
+        IS_NOT_MATCHED_VALUE: boolean;
+        value: KeygenResult;
+    } | null;
+    getPath(id: KeygenResult): TreePathType;
+    getChecked(id: KeygenResult): boolean | "indeterminate";
+    getKey(data: Item, id?: KeygenResult, index?: number): KeygenResult;
+    initValue(ids?: KeygenResult[], forceCheck?: boolean): 0 | undefined;
+    initData(data: Item[], path: KeygenResult[], disabled?: boolean, index?: number[]): KeygenResult[];
+    setData(data?: Item[], dispatch?: boolean): void;
+    subscribe(name: string, fn: Function): void;
+    unsubscribe(name: string, fn: Function): void;
+    dispatch(name: string, ...args: any): void;
+}
+export {};