amos-tool 1.4.4 → 1.4.8

package/apis/objectPath.md

@@ -1,129 +1,129 @@
-# objectPath
-
-## Usage
-
-```js
-var {objectPath} from 'amos-tool';
-
-var obj = {
-  a: {
-    b: "d",
-    c: ["e", "f"],
-    '\u1200': 'unicode key',
-    'dot.dot': 'key'
-  }
-};
-
-var objectPath = require("object-path");
-
-//get deep property
-objectPath.get(obj, "a.b");  //returns "d"
-objectPath.get(obj, ["a", "dot.dot"]);  //returns "key"
-objectPath.get(obj, 'a.\u1200');  //returns "unicode key"
-
-//get the first non-undefined value
-objectPath.coalesce(obj, ['a.z', 'a.d', ['a','b']], 'default');
-
-//empty a given path (but do not delete it) depending on their type,so it retains reference to objects and arrays.
-//functions that are not inherited from prototype are set to null.
-//object instances are considered objects and just own property names are deleted
-objectPath.empty(obj, 'a.b'); // obj.a.b is now ''
-objectPath.empty(obj, 'a.c'); // obj.a.c is now []
-objectPath.empty(obj, 'a'); // obj.a is now {}
-
-//works also with arrays
-objectPath.get(obj, "a.c.1");  //returns "f"
-objectPath.get(obj, ["a","c","1"]);  //returns "f"
-
-//can return a default value with get
-objectPath.get(obj, ["a.c.b"], "DEFAULT");  //returns "DEFAULT", since a.c.b path doesn't exists, if omitted, returns undefined
-
-//set
-objectPath.set(obj, "a.h", "m"); // or objectPath.set(obj, ["a","h"], "m");
-objectPath.get(obj, "a.h");  //returns "m"
-
-//set will create intermediate object/arrays
-objectPath.set(obj, "a.j.0.f", "m");
-
-//will insert values in array
-objectPath.insert(obj, "a.c", "m", 1); // obj.a.c = ["e", "m", "f"]
-
-//push into arrays (and create intermediate objects/arrays)
-objectPath.push(obj, "a.k", "o");
-
-//ensure a path exists (if it doesn't, set the default value you provide)
-objectPath.ensureExists(obj, "a.k.1", "DEFAULT");
-var oldVal = objectPath.ensureExists(obj, "a.b", "DEFAULT"); // oldval === "d"
-
-//deletes a path
-objectPath.del(obj, "a.b"); // obj.a.b is now undefined
-objectPath.del(obj, ["a","c",0]); // obj.a.c is now ['f']
-
-//tests path existence
-objectPath.has(obj, "a.b"); // true
-objectPath.has(obj, ["a","d"]); // false
-
-//bind object
-var model = objectPath({
-  a: {
-    b: "d",
-    c: ["e", "f"]
-  }
-});
-
-//now any method from above is supported directly w/o passing an object
-model.get("a.b");  //returns "d"
-model.get(["a.c.b"], "DEFAULT");  //returns "DEFAULT"
-model.del("a.b"); // obj.a.b is now undefined
-model.has("a.b"); // false
-
-```
-
-### How `object-path` deals with inherited properties
-
-By default `object-path` will only access an object's own properties. Look at the following example:
-
-```js
-var proto = {
-  notOwn: {prop: 'a'}
-}
-var obj = Object.create(proto);
-
-//This will return undefined (or the default value you specified), because notOwn is
-//an inherited property
-objectPath.get(obj, 'notOwn.prop');
-
-//This will set the property on the obj instance and not the prototype.
-//In other words proto.notOwn.prop === 'a' and obj.notOwn.prop === 'b'
-objectPath.set(obj, 'notOwn.prop', 'b');
-```
-
-To configure `object-path` to also deal with inherited properties, you need to create a new instance and specify
-the `includeInheritedProps = true` in the options object:
-
-```js
-var objectPath = require("object-path");
-var objectPathWithInheritedProps = objectPath.create({includeInheritedProps: true})
-```
-
-Alternatively, `object-path` exposes an instance already configured to handle inherited properties (`objectPath.withInheritedProps`):
-
-```js
-var objectPath = require("object-path");
-var objectPathWithInheritedProps = objectPath.withInheritedProps
-```
-
-Once you have the new instance, you can access inherited properties as you access other properties:
-
-```js
-var proto = {
-  notOwn: {prop: 'a'}
-}
-var obj = Object.create(proto);
-
-//This will return 'a'
-objectPath.withInheritedProps.get(obj, 'notOwn.prop');
-
-//This will set proto.notOwn.prop to 'b'
-objectPath.set(obj, 'notOwn.prop', 'b');
-```
+# objectPath
+
+## Usage
+
+```js
+var {objectPath} from 'amos-tool';
+
+var obj = {
+  a: {
+    b: "d",
+    c: ["e", "f"],
+    '\u1200': 'unicode key',
+    'dot.dot': 'key'
+  }
+};
+
+var objectPath = require("object-path");
+
+//get deep property
+objectPath.get(obj, "a.b");  //returns "d"
+objectPath.get(obj, ["a", "dot.dot"]);  //returns "key"
+objectPath.get(obj, 'a.\u1200');  //returns "unicode key"
+
+//get the first non-undefined value
+objectPath.coalesce(obj, ['a.z', 'a.d', ['a','b']], 'default');
+
+//empty a given path (but do not delete it) depending on their type,so it retains reference to objects and arrays.
+//functions that are not inherited from prototype are set to null.
+//object instances are considered objects and just own property names are deleted
+objectPath.empty(obj, 'a.b'); // obj.a.b is now ''
+objectPath.empty(obj, 'a.c'); // obj.a.c is now []
+objectPath.empty(obj, 'a'); // obj.a is now {}
+
+//works also with arrays
+objectPath.get(obj, "a.c.1");  //returns "f"
+objectPath.get(obj, ["a","c","1"]);  //returns "f"
+
+//can return a default value with get
+objectPath.get(obj, ["a.c.b"], "DEFAULT");  //returns "DEFAULT", since a.c.b path doesn't exists, if omitted, returns undefined
+
+//set
+objectPath.set(obj, "a.h", "m"); // or objectPath.set(obj, ["a","h"], "m");
+objectPath.get(obj, "a.h");  //returns "m"
+
+//set will create intermediate object/arrays
+objectPath.set(obj, "a.j.0.f", "m");
+
+//will insert values in array
+objectPath.insert(obj, "a.c", "m", 1); // obj.a.c = ["e", "m", "f"]
+
+//push into arrays (and create intermediate objects/arrays)
+objectPath.push(obj, "a.k", "o");
+
+//ensure a path exists (if it doesn't, set the default value you provide)
+objectPath.ensureExists(obj, "a.k.1", "DEFAULT");
+var oldVal = objectPath.ensureExists(obj, "a.b", "DEFAULT"); // oldval === "d"
+
+//deletes a path
+objectPath.del(obj, "a.b"); // obj.a.b is now undefined
+objectPath.del(obj, ["a","c",0]); // obj.a.c is now ['f']
+
+//tests path existence
+objectPath.has(obj, "a.b"); // true
+objectPath.has(obj, ["a","d"]); // false
+
+//bind object
+var model = objectPath({
+  a: {
+    b: "d",
+    c: ["e", "f"]
+  }
+});
+
+//now any method from above is supported directly w/o passing an object
+model.get("a.b");  //returns "d"
+model.get(["a.c.b"], "DEFAULT");  //returns "DEFAULT"
+model.del("a.b"); // obj.a.b is now undefined
+model.has("a.b"); // false
+
+```
+
+### How `object-path` deals with inherited properties
+
+By default `object-path` will only access an object's own properties. Look at the following example:
+
+```js
+var proto = {
+  notOwn: {prop: 'a'}
+}
+var obj = Object.create(proto);
+
+//This will return undefined (or the default value you specified), because notOwn is
+//an inherited property
+objectPath.get(obj, 'notOwn.prop');
+
+//This will set the property on the obj instance and not the prototype.
+//In other words proto.notOwn.prop === 'a' and obj.notOwn.prop === 'b'
+objectPath.set(obj, 'notOwn.prop', 'b');
+```
+
+To configure `object-path` to also deal with inherited properties, you need to create a new instance and specify
+the `includeInheritedProps = true` in the options object:
+
+```js
+var objectPath = require("object-path");
+var objectPathWithInheritedProps = objectPath.create({includeInheritedProps: true})
+```
+
+Alternatively, `object-path` exposes an instance already configured to handle inherited properties (`objectPath.withInheritedProps`):
+
+```js
+var objectPath = require("object-path");
+var objectPathWithInheritedProps = objectPath.withInheritedProps
+```
+
+Once you have the new instance, you can access inherited properties as you access other properties:
+
+```js
+var proto = {
+  notOwn: {prop: 'a'}
+}
+var obj = Object.create(proto);
+
+//This will return 'a'
+objectPath.withInheritedProps.get(obj, 'notOwn.prop');
+
+//This will set proto.notOwn.prop to 'b'
+objectPath.set(obj, 'notOwn.prop', 'b');
+```

package/index.d.ts

@@ -169,11 +169,14 @@ declare namespace LocationParam {
   export function parse(paramString: string): object;
   export function paramSearch(_name: string, target: string): void;
   /**
-   * 获取 location 中的所有参数
+   * - 获取 location 中的所有参数
+   * - 对 location.href 进行查找，支持 hash 方式的路由
    */
   export function getLocationParams(): object;
   /**
-   * 获取 location 中的参数
+   * - 获取 location 中的参数。
+   * - 采用 location.search 进行查找，因此，如果采用 react-router hash 方式，将无法获取到参数
+   * - why not support hash router? because in hash router location.search=''
    * @param name
    */
   export function getLocationParamByName(name: string): string | null;
@@ -384,12 +387,14 @@ declare namespace colorUtil {
    */
   export function toStringHexColor(stringRgb: string): string;
   /**
-   * 转化为hex颜色 （仅支持 RGB），如果是 rgba 时，则舍去 a
+   * - 转化为hex颜色 （仅支持 RGB），如果是 rgba 时，则舍去 a。
+   * - 如果传入的是 key color 则直接转化为与之对应的 hex 值
    * @param {string} stringRgb
    * @example
    *  toHexColor('rgba(241,112,19)'); // #f17013
    *  toHexColor('rgba(241,112,19, 1)'); // #f17013
    *  toHexColor('rgba(241,112,19, 0.1)'); // #f17013
+   *  toHexColor('red'); // #ff0000
    */
   export function toHexColor(stringRgb: string): string;
   /**
@@ -407,6 +412,15 @@ declare namespace colorUtil {
    */
   export function transformColor(hexColor: string): string;
   export function isHexColor(color: string): boolean;
+  /**
+   * 判断是否是内置 英文 color
+   * @param color
+   * @example
+   *  isKeyColor('red'); // true
+   *  isKeyColor('yellow'); // true
+   *  isKeyColor('asdfasdfa'); // false
+   */
+  export function isKeyColor(color: string): boolean;
   export function isRgbColor(color: string): boolean;
   /**
    * 将rgb颜色转化成object
@@ -425,6 +439,12 @@ declare namespace colorUtil {
    * objRGB2str({ r:1, g:1, b:1 }); // 'rgba(1,1,1)'
    */
   export function objRGB2str(color: object): string;
+  /**
+   * key color 转化为 hex color。
+   * 如果不是 key color 则直接返回 color 自身
+   * @param color
+   */
+  export function keyColorToHex(color: string): string;
   /**
    * 产生渐变色函数
    * @param color
@@ -550,9 +570,19 @@ export function objectValues(obj): any;
  * @param obj 目标对象
  * @param keys 需要删除的键
  * @example
- *  omit({ name: 'ilex', age: 16 }, ['age']) // { name: 'ilex' }
+ *  omit({ name: 'ilex', age: 16 }, ['age']); // { name: 'ilex' }
+ */
+export function omit(obj: object, keys: string | Array<String>): any;
+
+/**
+ * 从指定的 obj 中获取 指定的key组成新的对象
+ * @param obj
+ * @param keys
+ * @example
+ *  pick({ name: 'ilex', age: 16 }, ['age']); // { age: 16 }
+ *  pick({ name: 'ilex', age: 16 }, ['']); // {}
  */
-export function omit(obj: object, keys: string | Array<any>): any;
+export function pick(obj: Object | Function, keys: string | Array<String>): Object;
 /**
  * 将数据转化为json
  * @param data
@@ -959,6 +989,12 @@ declare namespace utils {
    * @return target
    */
   export function mergeAll(targetAndSources: Array<any>, overwrite?: boolean): object | Array<any>;
+  /**
+   * 比较 objTarget 中的所有属性值，是否在 objSource 中相等
+   * @param objSource
+   * @param objTarget
+   */
+  export function subObjectEqual(objSource: {}, objTarget: {}): Boolean;
 }
 
 declare namespace throttleDebounce {
@@ -1034,3 +1070,12 @@ declare const arrayMove: {
 	// TODO: Remove this for the next major release
 	default: typeof arrayMove;
 };
+
+declare namespace flat {
+  /**
+   * 获取树结构数据 flat keys
+   * @param item
+   * @param options
+   */
+  export function getTreeFlatKeys(item: Object | any[], options = { uniqueKey: 'key', childrenKey: 'children' }): String[] | Number[];
+}

package/index.js

@@ -1,3 +1,3 @@
-var amostool = require('./lib/amostool');
-
-module.exports = amostool;
+var amostool = require('./lib/amostool');
+
+module.exports = amostool;

package/lib/_browser.js

@@ -1,25 +1,27 @@
 "use strict";
+
 var Browser = {
   isFirefox: function() {
-    return "undefined" != typeof InstallTrigger
+    return "undefined" != typeof InstallTrigger;
   },
   isIE: function() {
-    return !!document.documentMode
+    return !!document.documentMode;
   },
   isEdge: function() {
-    return !Browser.isIE() && !!window.StyleMedia
+    return !Browser.isIE() && !!window.StyleMedia;
   },
   isChrome: function() {
-    return !!window.chrome && !!window.chrome.webstore
+    return !!window.chrome && !!window.chrome.webstore;
   },
   isSafari: function() {
-    return 0 < Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") || -1 !== navigator.userAgent.toLowerCase().indexOf("safari")
+    return Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") > 0 || -1 !== navigator.userAgent.toLowerCase().indexOf("safari");
   },
   wp: function() {
-    navigator.userAgent.match(/Windows Phone ([\d.]+)/)
+    navigator.userAgent.match(/Windows Phone ([\d.]+)/);
   },
   android: function() {
-    navigator.userAgent.match(/(Android);?[\s\/]+([\d.]+)?/)
+    navigator.userAgent.match(/(Android);?[\s\/]+([\d.]+)?/);
   }
 };
-module.exports = Browser;
+
+module.exports = Browser;

package/lib/_clone.js

@@ -1,74 +1,79 @@
 "use strict";
 
-function _typeof(e) {
-  return (_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
-    return typeof e
-  } : function(e) {
-    return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
-  })(e)
-}
-var findType = function(e) {
-  return Object.prototype.toString.call(e).match(/\[object (\w+)\]/)[1]
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"), _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")), findType = function(e) {
+  return Object.prototype.toString.call(e).match(/\[object (\w+)\]/)[1];
 };
 
 function findAllType(e) {
   switch (Object.prototype.toString.call(e)) {
-    case "[object Date]":
-      return "date";
-    case "[object RegExp]":
-      return "regexp";
-    case "[object Arguments]":
-      return "arguments";
-    case "[object Array]":
-      return "array";
-    case "[object Error]":
-      return "error"
+   case "[object Date]":
+    return "date";
+
+   case "[object RegExp]":
+    return "regexp";
+
+   case "[object Arguments]":
+    return "arguments";
+
+   case "[object Array]":
+    return "array";
+
+   case "[object Error]":
+    return "error";
   }
-  return null === e ? "null" : void 0 === e ? "undefined" : e && 1 === e.nodeType ? "element" : _typeof(e = e.valueOf ? e.valueOf() : Object.prototype.valueOf.apply(e))
+  return null === e ? "null" : void 0 === e ? "undefined" : e && 1 === e.nodeType ? "element" : (e = e.valueOf ? e.valueOf() : Object.prototype.valueOf.apply(e), 
+  (0, _typeof2.default)(e));
 }
-var simpleClone = function e(t) {
-    switch (findType(t)) {
-      case "Object":
-        var r = {};
-        for (var n in t) t.hasOwnProperty(n) && (r[n] = e(t[n]));
-        return r;
-      case "Array":
-        return t.slice()
-    }
-    return t
-  },
-  clone = function(t) {
-    try {
-      return JSON.parse(JSON.stringify(t, function(e, t) {
-        return "function" == typeof t ? t.toString() : t
-      }))
-    } catch (e) {
-      return t
-    }
-  },
-  cloneAll = function t(r) {
-    switch (findAllType(r)) {
-      case "object":
-        var n = {};
-        return Object.keys(r).forEach(function(e) {
-          "$" !== e.charAt(0) && (n[e] = t(r[e]))
-        }), n;
-      case "element":
-        return r.cloneNode(!0);
-      case "array":
-        for (var e = new Array(r.length), o = 0, c = r.length; o < c; o++) e[o] = t(r[o]);
-        return e;
-      case "regexp":
-        var l = "";
-        return l += r.multiline ? "m" : "", l += r.global ? "g" : "", l += r.ignoreCase ? "i" : "", new RegExp(r.source, l);
-      case "date":
-        return new Date(r.getTime());
-      default:
-        return r
-    }
-  };
+
+var simpleClone = function e(r) {
+  switch (findType(r)) {
+   case "Object":
+    var t = {};
+    for (var n in r) r.hasOwnProperty(n) && (t[n] = e(r[n]));
+    return t;
+
+   case "Array":
+    return r.slice();
+  }
+  return r;
+}, clone = function(e) {
+  try {
+    return JSON.parse(JSON.stringify(e, (function(e, r) {
+      return "function" == typeof r ? r.toString() : r;
+    })));
+  } catch (r) {
+    return e;
+  }
+}, cloneAll = function e(r) {
+  switch (findAllType(r)) {
+   case "object":
+    var t = {};
+    return Object.keys(r).forEach((function(n) {
+      "$" !== n.charAt(0) && (t[n] = e(r[n]));
+    })), t;
+
+   case "element":
+    return r.cloneNode(!0);
+
+   case "array":
+    for (var n = new Array(r.length), o = 0, l = r.length; o < l; o++) n[o] = e(r[o]);
+    return n;
+
+   case "regexp":
+    var a = "";
+    return a += r.multiline ? "m" : "", a += r.global ? "g" : "", a += r.ignoreCase ? "i" : "", 
+    new RegExp(r.source, a);
+
+   case "date":
+    return new Date(r.getTime());
+
+   default:
+    return r;
+  }
+};
+
 module.exports = {
   simpleClone: simpleClone,
   clone: clone,
   cloneAll: cloneAll
-};
+};

package/lib/_cookie.js

@@ -1,68 +1,71 @@
 "use strict";
-var decode = decodeURIComponent,
-  encode = encodeURIComponent,
-  pairSplitRegExp = /; */,
-  fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+
+var decode = decodeURIComponent, encode = encodeURIComponent, pairSplitRegExp = /; */, fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
 
 function parse(e, t) {
   if ("string" != typeof e) throw new TypeError("argument str must be a string");
   for (var r = {}, i = t || {}, n = e.split(pairSplitRegExp), o = i.decode || decode, a = 0; a < n.length; a++) {
-    var s, p, d = n[a],
-      f = d.indexOf("=");
-    f < 0 || (s = d.substr(0, f).trim(), '"' == (p = d.substr(++f, d.length).trim())[0] && (p = p.slice(1, -1)), null == r[s] && (r[s] = tryDecode(p, o)))
+    var s = n[a], p = s.indexOf("=");
+    if (!(p < 0)) {
+      var d = s.substr(0, p).trim(), f = s.substr(++p, s.length).trim();
+      '"' == f[0] && (f = f.slice(1, -1)), null == r[d] && (r[d] = tryDecode(f, o));
+    }
   }
-  return r
+  return r;
 }
 
 function serialize(e, t, r) {
-  var i = r || {},
-    n = i.encode || encode;
+  var i = r || {}, n = i.encode || encode;
   if ("function" != typeof n) throw new TypeError("option encode is invalid");
   if (!fieldContentRegExp.test(e)) throw new TypeError("argument name is invalid");
   var o = n(t);
   if (o && !fieldContentRegExp.test(o)) throw new TypeError("argument val is invalid");
   var a = e + "=" + o;
   if (null != i.maxAge) {
-    var s = +i.maxAge;
+    var s = i.maxAge - 0;
     if (isNaN(s)) throw new Error("maxAge should be a Number");
-    a += "; Max-Age=" + Math.floor(s)
+    a += "; Max-Age=" + Math.floor(s);
   }
   if (i.domain) {
     if (!fieldContentRegExp.test(i.domain)) throw new TypeError("option domain is invalid");
-    a += "; Domain=" + i.domain
+    a += "; Domain=" + i.domain;
   }
   if (i.path) {
     if (!fieldContentRegExp.test(i.path)) throw new TypeError("option path is invalid");
-    a += "; Path=" + i.path
+    a += "; Path=" + i.path;
   }
   if (i.expires) {
     if ("function" != typeof i.expires.toUTCString) throw new TypeError("option expires is invalid");
-    a += "; Expires=" + i.expires.toUTCString()
+    a += "; Expires=" + i.expires.toUTCString();
   }
   if (i.httpOnly && (a += "; HttpOnly"), i.secure && (a += "; Secure"), i.sameSite) switch ("string" == typeof i.sameSite ? i.sameSite.toLowerCase() : i.sameSite) {
-    case !0:
-      a += "; SameSite=Strict";
-      break;
-    case "lax":
-      a += "; SameSite=Lax";
-      break;
-    case "strict":
-      a += "; SameSite=Strict";
-      break;
-    default:
-      throw new TypeError("option sameSite is invalid")
+   case !0:
+    a += "; SameSite=Strict";
+    break;
+
+   case "lax":
+    a += "; SameSite=Lax";
+    break;
+
+   case "strict":
+    a += "; SameSite=Strict";
+    break;
+
+   default:
+    throw new TypeError("option sameSite is invalid");
   }
-  return a
+  return a;
 }
 
-function tryDecode(t, e) {
+function tryDecode(e, t) {
   try {
-    return e(t)
-  } catch (e) {
-    return t
+    return t(e);
+  } catch (t) {
+    return e;
   }
 }
+
 module.exports = {
   parse: parse,
   serialize: serialize
-};
+};