shineout 1.12.2 → 1.12.3

package/esm/utils/transform.js

@@ -0,0 +1,30 @@
+function mapToArray(map, api) {
+  if (!map || map.size === 0) return [];
+  var v = [];
+  var it = map[api]();
+
+  for (var _iterator = it, _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 i = _ref;
+    v.push(i);
+  }
+
+  return v;
+}
+
+export function keysToArray(map) {
+  return mapToArray(map, 'keys');
+}
+export function valuesToArray(map) {
+  return mapToArray(map, 'values');
+}

package/esm/utils/tree.d.ts

@@ -0,0 +1,14 @@
+declare type ExpandKeys = (string | number)[];
+interface Conf {
+    advanced?: boolean;
+}
+export declare const getFilterTree: <T, K extends Function>(treeNodes: T[] | undefined, filterFunc: (data: T) => boolean, filterExpandKeys: ExpandKeys | undefined, keyFunc: K, childrenKey: keyof T | undefined, showHitDescendants: boolean, firstMatchNode?: ((node: T) => void) | undefined, { advanced }?: Conf) => (T | null)[];
+export declare const getFlattenTree: <T>(data: T[], childrenKey?: keyof T, wide?: boolean | undefined) => T[][];
+declare type FilterDatum<T> = {
+    data: T[];
+    childrenKey: string;
+    getKey: (node: T) => string;
+    getDataById: (id: string) => T;
+};
+export declare const mergeFilteredTree: (filterDatum: FilterDatum<any>, rawDatum: FilterDatum<any>, tiledId: string[]) => any[];
+export {};

package/esm/utils/tree.js

@@ -0,0 +1,93 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import immer from 'immer';
+import { deepClone } from './clone';
+export var getFilterTree = function getFilterTree(treeNodes, filterFunc, filterExpandKeys, keyFunc, childrenKey, showHitDescendants, firstMatchNode, _temp) {
+  if (childrenKey === void 0) {
+    childrenKey = 'children';
+  }
+
+  var _ref = _temp === void 0 ? {} : _temp,
+      advanced = _ref.advanced;
+
+  var mapFilteredNodeToData = function mapFilteredNodeToData(node) {
+    if (!node) return null;
+    var match = false;
+
+    if (filterFunc(node)) {
+      if (firstMatchNode) firstMatchNode(node);
+      match = true;
+    }
+
+    var children = (node[childrenKey] || []).map(mapFilteredNodeToData).filter(function (n) {
+      return n;
+    });
+
+    if (children.length || match) {
+      var _objectSpread2;
+
+      var key = keyFunc(node);
+      if (filterExpandKeys && children.length > 0) filterExpandKeys.push(key);
+      if (!node[childrenKey]) return node;
+      var childNodes = showHitDescendants && match ? node[childrenKey] || [] : children;
+      if (advanced && match && children.length > 0) childNodes = children;
+      return _objectSpread({}, node, (_objectSpread2 = {}, _objectSpread2[childrenKey] = childNodes, _objectSpread2));
+    }
+
+    return null;
+  };
+
+  return treeNodes.map(mapFilteredNodeToData).filter(function (node) {
+    return node;
+  });
+};
+export var getFlattenTree = function getFlattenTree(data, childrenKey, wide) {
+  if (childrenKey === void 0) {
+    childrenKey = 'children';
+  }
+
+  var arr = [];
+
+  var flatten = function flatten(list, path) {
+    list.forEach(function (item) {
+      var children = item[childrenKey];
+
+      if (children && children.length > 0) {
+        var clonedPath = [].concat(path);
+        clonedPath.push(item);
+        if (wide) arr.push(clonedPath);
+        flatten(children, clonedPath);
+      } else {
+        arr.push([].concat(path, [item]));
+      }
+    });
+  };
+
+  flatten(data, []);
+  return arr;
+};
+export var mergeFilteredTree = function mergeFilteredTree(filterDatum, rawDatum, tiledId) {
+  var filterData = filterDatum.data;
+  var childrenKey = filterDatum.childrenKey;
+  if (tiledId.length === 0) return filterData;
+
+  var recursion = function recursion(node) {
+    var nodeKey = filterDatum.getKey(node);
+
+    if (tiledId.indexOf(nodeKey) >= 0) {
+      node[childrenKey] = deepClone(rawDatum.getDataById(nodeKey)[childrenKey] || []);
+    } else {
+      var item = filterDatum.getDataById(nodeKey);
+
+      if (item && item[childrenKey]) {
+        node[childrenKey] = deepClone(item[childrenKey] || []);
+      }
+    }
+
+    var children = node[childrenKey] || [];
+    children.map(recursion);
+  };
+
+  return immer(filterData, function (draft) {
+    draft.map(recursion);
+  });
+};

package/esm/utils/uid.d.ts

@@ -0,0 +1,5 @@
+import { v4 as getUUid } from 'uuid';
+import { KeygenType } from '../@types/common';
+export declare function getUidStr(...args: Parameters<typeof getUUid>): string;
+export declare function getKey<T>(...args: [T, KeygenType<T>, number?]): string | number;
+export declare const defer: any;

package/esm/utils/uid.js

@@ -0,0 +1,23 @@
+import { v4 as getUUid } from 'uuid';
+export function getUidStr() {
+  // dom id  cannot start with number
+  return "a" + getUUid.apply(void 0, arguments);
+}
+
+function $getKey(d, gen, index) {
+  if (gen === true) return d;
+  if (typeof gen === 'string') return d[gen];
+  if (typeof gen === 'function') return gen(d, index);
+  return index;
+}
+
+export function getKey() {
+  var key = $getKey.apply(void 0, arguments);
+
+  if (typeof key !== 'string' && typeof key !== 'number') {
+    console.error(new Error("keygen result expect a string or a number, get '" + typeof key + "'"));
+  }
+
+  return key;
+}
+export var defer = typeof Promise === 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;

package/esm/utils/validate/index.d.ts

@@ -0,0 +1,4 @@
+import { FormItemRule } from '../../Rule/Props';
+import { ObjectType } from '../../@types/common';
+declare const validate: <Value, Props extends ObjectType<any>>(value: Value, formdata: ObjectType, rules: FormItemRule<Value, any, any>, props: Props) => Promise<unknown>;
+export default validate;

package/esm/utils/validate/index.js

@@ -0,0 +1,109 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import Datum from '../../Datum';
+import { wrapFormError } from '../errors';
+import { substitute } from '../strings';
+import { flattenArray } from '../flat';
+import range from './range';
+import rangeLength from './rangeLength';
+import required from './required';
+import typeOf from './type';
+import regTest from './regExp';
+
+function getRule(rules, props) {
+  if (props === void 0) {
+    props = {};
+  }
+
+  if (typeof rules === 'function') {
+    if (rules.isInnerValidator) rules = rules();else return rules;
+  }
+
+  if (typeof props === 'string') props = {
+    type: props
+  };
+
+  var _rules = rules,
+      _rules$type = _rules.type,
+      type = _rules$type === void 0 ? props.type : _rules$type,
+      message = _rules.message,
+      regExp = _rules.regExp,
+      func = _rules.func,
+      other = _objectWithoutPropertiesLoose(_rules, ["type", "message", "regExp", "func"]);
+
+  props = Object.assign({}, props, other);
+  props.message = typeof message === 'function' ? message(props) : substitute(message, props);
+  if (func) return function (value, formData, callback) {
+    return func(value, formData, callback, props);
+  };
+  if (other.required !== undefined) return required({
+    message: props.message,
+    required: !!props.required
+  });
+  if (regExp) return regTest(regExp, {
+    message: props.message
+  });
+
+  if (other.min !== undefined || other.max !== undefined) {
+    if (type === 'number' || type === 'integer') {
+      return range({
+        message: props.message,
+        min: other.min,
+        max: other.max
+      });
+    }
+
+    return rangeLength({
+      message: props.message,
+      min: other.min,
+      max: other.max
+    });
+  }
+
+  if (type) return typeOf(type, props.message);
+  var err = new Error("Rule " + JSON.stringify(rules) + " is not valid.");
+  console.error(err);
+  throw err;
+}
+
+var validate = function validate(value, formdata, rules, props) {
+  return new Promise(function (resolve, reject) {
+    var $rules = flattenArray(rules);
+    var rule = $rules.shift();
+
+    if (rule === undefined) {
+      resolve(true);
+      return;
+    }
+
+    if (!rule) {
+      validate(value, formdata, $rules, props).then(resolve, reject);
+      return;
+    }
+
+    var callback = function callback(result) {
+      if (result !== true) {
+        reject(wrapFormError(result));
+        return;
+      }
+
+      validate(value, formdata, $rules, props).then(resolve, reject);
+    };
+
+    var fn = getRule(rule, props);
+    var val = value;
+
+    if (fn === rule && (value instanceof Datum.List || value instanceof Datum.Form)) {
+      val = value.getValue();
+    }
+
+    var cb = fn(val, formdata, callback);
+
+    if (cb && cb.then) {
+      cb.then(callback.bind(null, true)).catch(function (e) {
+        reject(wrapFormError(e));
+      });
+    }
+  });
+};
+
+export default validate;

package/esm/utils/validate/isJson.d.ts

@@ -0,0 +1 @@
+export default function (value: unknown): boolean;

package/esm/utils/validate/isJson.js

@@ -0,0 +1,30 @@
+export default function (value) {
+  if (typeof value === 'object') return true; // In the second stage, we run the text against
+  // regular expressions that look for non-JSON patterns. We are especially
+  // concerned with '()' and 'new' because they can cause invocation, and '='
+  // because it can cause mutation. But just to be safe, we want to reject all
+  // unexpected forms.
+  // We split the second stage into 4 regexp operations in order to work around
+  // crippling inefficiencies in IE's and Safari's regexp engines. First we
+  // replace all backslash pairs with '@' (a non-JSON character). Second, we
+  // replace all simple value tokens with ']' characters. Third, we delete all
+  // open brackets that follow a colon or comma or that begin the text. Finally,
+  // we look to see that the remaining characters are only whitespace or ']' or
+  // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+  // eslint-disable-next-line
+
+  if (typeof value === 'string') {
+    if (/^[\],:{}\s]*$/.test(value.replace(/\\["\\\/bfnrtu]/g, '@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+      try {
+        JSON.parse(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}

package/esm/utils/validate/nullable.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (fn: (...args: unknown[]) => void) => (value: any, formdata: object, callback: (...args: (boolean | Error)[]) => void) => void;
+export default _default;

package/esm/utils/validate/nullable.js

@@ -0,0 +1,10 @@
+export default (function (fn) {
+  return function (value, formdata, callback) {
+    if (value == null || value.length === 0) {
+      callback(true);
+      return;
+    }
+
+    fn(value, formdata, callback);
+  };
+});

package/esm/utils/validate/range.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (options: {
+    min?: number;
+    max?: number;
+    message: string;
+}) => (value: any, formdata: object, callback: (...args: (boolean | Error)[]) => void) => void;
+export default _default;

package/esm/utils/validate/range.js

@@ -0,0 +1,29 @@
+import nullable from './nullable';
+export default (function (options) {
+  return nullable(function (value, _formdata, callback) {
+    var min = options.min,
+        max = options.max,
+        message = options.message;
+
+    if (value === undefined || value === '') {
+      callback(true);
+      return;
+    }
+
+    var val = parseFloat(String(value));
+
+    if (Number.isNaN(val)) {
+      // console.error(new Error(`Can not convert value '${value}' to Number, validate failed.`))
+      callback(new Error(message));
+      return;
+    }
+
+    if (typeof min === 'number' && val < min || typeof max === 'number' && val > max) {
+      callback(new Error(message));
+      return;
+    } else {
+      callback(true);
+      return;
+    }
+  });
+});

package/esm/utils/validate/rangeLength.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (options: {
+    min?: number;
+    max?: number;
+    message: string;
+}) => (value: any, _formdata: object, callback: (x: boolean | Error) => void) => void;
+export default _default;

package/esm/utils/validate/rangeLength.js

@@ -0,0 +1,22 @@
+import { isEmpty } from '../is';
+export default (function (options) {
+  return function (value, _formdata, callback) {
+    var min = options.min,
+        max = options.max,
+        message = options.message;
+    var error = new Error(message);
+
+    if (isEmpty(value)) {
+      if (min) callback(error);else callback(true);
+      return;
+    }
+
+    var len = typeof value === 'number' ? value.toString().length : value.length;
+
+    if (len !== undefined && typeof min === 'number' && len < min || len !== undefined && typeof max === 'number' && len > max) {
+      callback(error);
+    } else {
+      callback(true);
+    }
+  };
+});

package/esm/utils/validate/regExp.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (regExp: string | RegExp | undefined, options: {
+    message: string;
+}) => (value: any, formdata: object, callback: (...args: (boolean | Error)[]) => void) => void;
+export default _default;

package/esm/utils/validate/regExp.js

@@ -0,0 +1,21 @@
+import nullable from './nullable';
+export default (function (regExp, options) {
+  return nullable(function (value, _formdata, callback) {
+    var message = options.message;
+    var reg = typeof regExp === 'string' ? new RegExp(regExp) : regExp;
+
+    if (!reg) {
+      callback(new Error(message));
+      return;
+    }
+
+    if (reg.global) reg.lastIndex = 0;
+
+    if (typeof value === 'string' && reg.test(value)) {
+      callback(true);
+    } else {
+      callback(new Error(message));
+      return;
+    }
+  });
+});

package/esm/utils/validate/required.d.ts

@@ -0,0 +1,5 @@
+declare const _default: (options: {
+    message: string;
+    required: boolean;
+}) => (value: any, _formdata: any, callback: (msg: true | Error) => void) => void;
+export default _default;

package/esm/utils/validate/required.js

@@ -0,0 +1,18 @@
+export default (function (options) {
+  return function (value, _formdata, callback) {
+    var message = options.message,
+        required = options.required;
+
+    if (required === false) {
+      callback(true);
+      return;
+    }
+
+    if (value == null || value.length === 0) {
+      callback(new Error(message));
+      return;
+    } else {
+      callback(true);
+    }
+  };
+});

package/esm/utils/validate/type.d.ts

@@ -0,0 +1,14 @@
+export declare type RuleType = keyof typeof regs | 'json';
+export declare const regs: {
+    readonly email: RegExp;
+    readonly integer: RegExp;
+    readonly number: RegExp;
+    readonly tel: RegExp;
+    readonly hex: RegExp;
+    readonly rgb: RegExp;
+    readonly rgba: RegExp;
+    readonly ipv4: RegExp;
+    readonly url: RegExp;
+};
+declare const _default: (type: RuleType, message?: string | Function | undefined) => (value: any, formdata: object, callback: (...args: (boolean | Error)[]) => void) => void;
+export default _default;

package/esm/utils/validate/type.js

@@ -0,0 +1,93 @@
+import nullable from './nullable';
+import isJson from './isJson';
+/* eslint-disable */
+
+export var regs = {
+  get email() {
+    return /^((([a-zA-Z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-zA-Z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-zA-Z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-zA-Z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-zA-Z]|\d|-|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-zA-Z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-zA-Z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-zA-Z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-zA-Z]|\d|-|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-zA-Z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/;
+  },
+
+  get integer() {
+    return /^[-+]?[0-9]*$/;
+  },
+
+  get number() {
+    return /^-?(\d*\.)?\d+(e[-+]?\d+)?$/i;
+  },
+
+  get tel() {
+    return /^[\d\s ().-]+$/;
+  },
+
+  get hex() {
+    return /^#[0-9a-f]{6}?$/i;
+  },
+
+  get rgb() {
+    return new RegExp('^rgb\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*\\)$');
+  },
+
+  get rgba() {
+    return new RegExp('^rgba\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*((0.[1-9]*)|[01])\\s*\\)$');
+  },
+
+  get ipv4() {
+    return /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+  },
+
+  get url() {
+    return new RegExp('^' + // protocol identifier
+    '(?:(?:https?|ftp)://)?' + // ** mod: make scheme optional
+    // user:pass authentication
+    '(?:\\S+(?::\\S*)?@)?' + '(?:' + // IP address exclusion
+    // private & local networks
+    // "(?!(?:10|127)(?:\\.\\d{1,3}){3})" +   // ** mod: allow local networks
+    // "(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})" +  // ** mod: allow local networks
+    // "(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})" +  // ** mod: allow local networks
+    // IP address dotted notation octets
+    // excludes loopback network 0.0.0.0
+    // excludes reserved space >= 224.0.0.0
+    // excludes network & broacast addresses
+    // (first & last IP address of each class)
+    '(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])' + '(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}' + '(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))' + '|' + // host name
+    "(?:(?:[a-zA-Z\\u00a1-\\uffff0-9]-*)*[a-zA-Z\\u00a1-\\uffff0-9]+)" + // domain name
+    "(?:\\.(?:[a-zA-Z\\u00a1-\\uffff0-9]-*)*[a-zA-Z\\u00a1-\\uffff0-9]+)*" + // TLD identifier
+    "(?:\\.(?:[a-zA-Z\\u00a1-\\uffff]{2,}))" + ')' + // port number
+    '(?::\\d{2,5})?' + // resource path
+    '(?:/\\S*)?' + '$');
+  }
+
+};
+/* eslint-enable */
+
+export default (function (type, message) {
+  return nullable(function (value, _formdata, callback) {
+    var error;
+
+    if (typeof message === 'string') {
+      error = new Error(message);
+    }
+
+    if (typeof message === 'function') {
+      error = new Error(message());
+    }
+
+    if (type === 'json') {
+      if (isJson(value)) callback(true);else callback(error);
+      return;
+    }
+
+    var reg = regs[type];
+
+    if (!reg) {
+      console.error(new Error("Type '" + type + "' not existed."));
+      callback(new Error("Validate failured. Type '" + type + "' not existed."));
+    }
+
+    if (typeof value === 'string' && reg.test(value)) {
+      callback(true);
+    } else {
+      callback(error);
+    }
+  });
+});