fantasy-ngzorro 1.3.33 → 1.3.35

package/esm5/utils.js

@@ -2,76 +2,117 @@
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+import * as tslib_1 from "tslib";
+import { round } from 'lodash';
 // 工具类
-var ɵ0 = /**
- * @param {?} formList
- * @param {?} name
- * @param {?} options
- * @return {?}
- */
-function (formList, name, options) {
-    /** @type {?} */
-    var returnData = formList;
-    if (!returnData || !returnData.length) {
-        return returnData;
-    }
-    /** @type {?} */
-    var length = formList.length;
-    for (var i = 0; i < length; i++) {
-        if (returnData[i].name === name) {
-            returnData[i].selectOption.selectList = options;
+/** @type {?} */
+export var Utils = {
+    /**
+     * 填充select控件选项
+     * @param formList 入参数组 Array<any>
+     * @param name 需要填充options的属性名称
+     * @param options 选项列表
+     */
+    fillSelectOption: /**
+     * 填充select控件选项
+     * @param {?} formList 入参数组 Array<any>
+     * @param {?} name 需要填充options的属性名称
+     * @param {?} options 选项列表
+     * @return {?}
+     */
+    function (formList, name, options) {
+        /** @type {?} */
+        var returnData = formList;
+        if (!returnData || !returnData.length) {
+            return returnData;
         }
-    }
-    return returnData;
-}, ɵ1 = /**
- * @param {?} list
- * @param {?} obj
- * @return {?}
- */
-function (list, obj) {
-    /** @type {?} */
-    var returnData = [];
-    if (!list || !list.length) {
-        return returnData;
-    }
-    /** @type {?} */
-    var length = list.length;
-    for (var i = 0; i < length; i++) {
-        if (obj[list[i].name]) {
-            list[i].value = obj[list[i].name];
+        /** @type {?} */
+        var length = formList.length;
+        for (var i = 0; i < length; i++) {
+            if (returnData[i].name === name) {
+                returnData[i].selectOption.selectList = options;
+            }
         }
-    }
-    return list;
-}, ɵ2 = /**
- * @param {?} list
- * @param {?=} option
- * @return {?}
- */
-function (list, option) {
-    /** @type {?} */
-    var returnData = [];
-    if (!list || !list.length) {
         return returnData;
-    }
-    if (option) {
-        if (option.labelTip && option.valueTip) {
-            list.forEach((/**
-             * @param {?} item
-             * @return {?}
-             */
-            function (item) {
-                /** @type {?} */
-                var returnItem = item;
-                returnItem.label = item[option.label];
-                returnItem.value = item[option.value];
-                if (option.valueTip) {
-                    returnItem[option.valueTip] = item[option.value];
-                }
-                if (option.labelTip) {
-                    returnItem[option.labelTip] = item[option.label];
-                }
-                returnData.push(returnItem);
-            }));
+    },
+    /**
+     * 填充FormItem数组：针对入参list的每一个FormItem，判断obj中是否有对应的name字段，如果有，则填充value。
+     * @param list 入参数组 Array<FormItem>
+     * @param obj 需要填充到list的属性
+     */
+    fillArrayFormItem: /**
+     * 填充FormItem数组：针对入参list的每一个FormItem，判断obj中是否有对应的name字段，如果有，则填充value。
+     * @param {?} list 入参数组 Array<FormItem>
+     * @param {?} obj 需要填充到list的属性
+     * @return {?}
+     */
+    function (list, obj) {
+        /** @type {?} */
+        var returnData = [];
+        if (!list || !list.length) {
+            return returnData;
+        }
+        /** @type {?} */
+        var length = list.length;
+        for (var i = 0; i < length; i++) {
+            if (obj[list[i].name]) {
+                list[i].value = obj[list[i].name];
+            }
+        }
+        return list;
+    },
+    /**
+     * 数组转换成选择器的选项数组
+     * @param list 入参数组 字符串数组或对象数组
+     * @param option 转换选项
+     * 注：list为字符串数组，option不需要传，按照标准的label、value转换
+     */
+    arrayToSelectOptionList: /**
+     * 数组转换成选择器的选项数组
+     * @param {?} list 入参数组 字符串数组或对象数组
+     * @param {?=} option 转换选项
+     * 注：list为字符串数组，option不需要传，按照标准的label、value转换
+     * @return {?}
+     */
+    function (list, option) {
+        /** @type {?} */
+        var returnData = [];
+        if (!list || !list.length) {
+            return returnData;
+        }
+        if (option) {
+            if (option.labelTip && option.valueTip) {
+                list.forEach((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) {
+                    /** @type {?} */
+                    var returnItem = item;
+                    returnItem.label = item[option.label];
+                    returnItem.value = item[option.value];
+                    if (option.valueTip) {
+                        returnItem[option.valueTip] = item[option.value];
+                    }
+                    if (option.labelTip) {
+                        returnItem[option.labelTip] = item[option.label];
+                    }
+                    returnData.push(returnItem);
+                }));
+            }
+            else {
+                list.forEach((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (item) {
+                    /** @type {?} */
+                    var returnItem = item;
+                    returnItem.label = item[option.label];
+                    returnItem.value = item[option.value];
+                    returnData.push(returnItem);
+                }));
+            }
         }
         else {
             list.forEach((/**
@@ -80,50 +121,186 @@ function (list, option) {
              */
             function (item) {
                 /** @type {?} */
-                var returnItem = item;
-                returnItem.label = item[option.label];
-                returnItem.value = item[option.value];
+                var returnItem = {};
+                returnItem.label = item;
+                returnItem.value = item;
                 returnData.push(returnItem);
             }));
         }
-    }
-    else {
-        list.forEach((/**
-         * @param {?} item
+        return returnData;
+    },
+    /**
+     * 求和
+     * @param nums 数组
+     * @param precision 精度
+     */
+    add: /**
+     * 求和
+     * @param {?} nums 数组
+     * @param {?=} precision 精度
+     * @return {?}
+     */
+    function (nums, precision) {
+        var e_1, _a;
+        if (precision === void 0) { precision = 2; }
+        if (!Array.isArray(nums)) {
+            throw new Error('参数必须是数组');
+        }
+        if (nums.some((/**
+         * @param {?} num
          * @return {?}
          */
-        function (item) {
-            /** @type {?} */
-            var returnItem = {};
-            returnItem.label = item;
-            returnItem.value = item;
-            returnData.push(returnItem);
-        }));
-    }
-    return returnData;
-};
-/** @type {?} */
-export var Utils = {
+        function (num) { return typeof num !== 'number'; }))) {
+            throw new Error('数组元素必须是数字');
+        }
+        /** @type {?} */
+        var result = 0;
+        try {
+            for (var nums_1 = tslib_1.__values(nums), nums_1_1 = nums_1.next(); !nums_1_1.done; nums_1_1 = nums_1.next()) {
+                var num = nums_1_1.value;
+                result += num;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (nums_1_1 && !nums_1_1.done && (_a = nums_1.return)) _a.call(nums_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return round(result, precision);
+    },
     /**
-     * 填充select控件选项
-     * @param formList 入参数组 Array<any>
-     * @param name 需要填充options的属性名称
-     * @param options 选项列表
+     * 减法
+     * @param nums 数组
+     * @param precision 精度
+     */
+    subtract: /**
+     * 减法
+     * @param {?} nums 数组
+     * @param {?=} precision 精度
+     * @return {?}
      */
-    fillSelectOption: (ɵ0),
+    function (nums, precision) {
+        var e_2, _a;
+        if (precision === void 0) { precision = 2; }
+        if (!Array.isArray(nums)) {
+            throw new Error('参数必须是数组');
+        }
+        if (nums.some((/**
+         * @param {?} num
+         * @return {?}
+         */
+        function (num) { return typeof num !== 'number'; }))) {
+            throw new Error('数组元素必须是数字');
+        }
+        if (nums.length < 2) {
+            throw new Error('减法入参数量至少要2个！');
+        }
+        /** @type {?} */
+        var result = nums.shift();
+        try {
+            for (var nums_2 = tslib_1.__values(nums), nums_2_1 = nums_2.next(); !nums_2_1.done; nums_2_1 = nums_2.next()) {
+                var num = nums_2_1.value;
+                result -= num;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (nums_2_1 && !nums_2_1.done && (_a = nums_2.return)) _a.call(nums_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return round(result, precision);
+    },
     /**
-     * 填充FormItem数组：针对入参list的每一个FormItem，判断obj中是否有对应的name字段，如果有，则填充value。
-     * @param list 入参数组 Array<FormItem>
-     * @param obj 需要填充到list的属性
+     * 乘法
+     * @param nums 数组
+     * @param precision 精度
      */
-    fillArrayFormItem: (ɵ1),
+    multiply: /**
+     * 乘法
+     * @param {?} nums 数组
+     * @param {?=} precision 精度
+     * @return {?}
+     */
+    function (nums, precision) {
+        var e_3, _a;
+        if (precision === void 0) { precision = 2; }
+        if (!Array.isArray(nums)) {
+            throw new Error('参数必须是数组');
+        }
+        if (nums.some((/**
+         * @param {?} num
+         * @return {?}
+         */
+        function (num) { return typeof num !== 'number'; }))) {
+            throw new Error('数组元素必须是数字');
+        }
+        /** @type {?} */
+        var result = 1;
+        try {
+            for (var nums_3 = tslib_1.__values(nums), nums_3_1 = nums_3.next(); !nums_3_1.done; nums_3_1 = nums_3.next()) {
+                var num = nums_3_1.value;
+                result = result * num;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (nums_3_1 && !nums_3_1.done && (_a = nums_3.return)) _a.call(nums_3);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return round(result, precision);
+    },
     /**
-     * 数组转换成选择器的选项数组
-     * @param list 入参数组 字符串数组或对象数组
-     * @param option 转换选项
-     * 注：list为字符串数组，option不需要传，按照标准的label、value转换
+     * 除法
+     * @param nums 数组
+     * @param precision 精度
+     */
+    divide: /**
+     * 除法
+     * @param {?} nums 数组
+     * @param {?=} precision 精度
+     * @return {?}
      */
-    arrayToSelectOptionList: (ɵ2)
+    function (nums, precision) {
+        var e_4, _a;
+        if (precision === void 0) { precision = 2; }
+        if (!Array.isArray(nums)) {
+            throw new Error('参数必须是数组');
+        }
+        if (nums.some((/**
+         * @param {?} num
+         * @return {?}
+         */
+        function (num) { return typeof num !== 'number'; }))) {
+            throw new Error('数组元素必须是数字');
+        }
+        if (nums.length < 2) {
+            throw new Error('除法入参数量至少要2个！');
+        }
+        /** @type {?} */
+        var result = nums.shift();
+        try {
+            for (var nums_4 = tslib_1.__values(nums), nums_4_1 = nums_4.next(); !nums_4_1.done; nums_4_1 = nums_4.next()) {
+                var num = nums_4_1.value;
+                if (num === 0) {
+                    throw new Error('除数不能为0！');
+                }
+                result = result / num;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (nums_4_1 && !nums_4_1.done && (_a = nums_4.return)) _a.call(nums_4);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return round(result, precision);
+    }
 };
-export { ɵ0, ɵ1, ɵ2 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"ng://fantasy-ngzorro/","sources":["utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormItem } from './hd-form/hd-form.service';\nimport { round } from 'lodash';\n// 工具类\nexport const Utils = {\n  /**\n   * 填充select控件选项\n   * @param formList 入参数组 Array<any>\n   * @param name 需要填充options的属性名称\n   * @param options 选项列表\n   */\n  fillSelectOption(formList: Array<any>, name: string, options: Array<any>) {\n    const returnData = formList;\n    if (!returnData || !returnData.length) {\n      return returnData;\n    }\n    const length = formList.length;\n    for (let i = 0; i < length; i++) {\n      if (returnData[i].name === name) {\n        returnData[i].selectOption.selectList = options;\n      }\n    }\n    return returnData;\n  },\n\n  /**\n   * 填充FormItem数组：针对入参list的每一个FormItem，判断obj中是否有对应的name字段，如果有，则填充value。\n   * @param list 入参数组 Array<FormItem>\n   * @param obj 需要填充到list的属性\n   */\n  fillArrayFormItem(list: Array<FormItem>, obj: Object) {\n    const returnData = [];\n    if (!list || !list.length) {\n      return returnData;\n    }\n    const length = list.length;\n    for (let i = 0; i < length; i++) {\n      if (obj[list[i].name]) {\n        list[i].value = obj[list[i].name];\n      }\n    }\n    return list;\n  },\n\n  /**\n   * 数组转换成选择器的选项数组\n   * @param list 入参数组 字符串数组或对象数组\n   * @param option 转换选项\n   * 注：list为字符串数组，option不需要传，按照标准的label、value转换\n   */\n  arrayToSelectOptionList(list: Array<any>, option?: {\n    value: string,\n    label: string,\n    valueTip?: string,\n    labelTip?: string\n  }) {\n    const returnData = [];\n    if (!list || !list.length) {\n      return returnData;\n    }\n    if (option) {\n      if (option.labelTip && option.valueTip) {\n        list.forEach((item) => {\n          const returnItem: any = item;\n          returnItem.label = item[option.label];\n          returnItem.value = item[option.value];\n          if (option.valueTip) {\n            returnItem[option.valueTip] = item[option.value];\n          }\n          if (option.labelTip) {\n            returnItem[option.labelTip] = item[option.label];\n          }\n          returnData.push(returnItem);\n        });\n      } else {\n        list.forEach((item) => {\n          const returnItem: any = item;\n          returnItem.label = item[option.label];\n          returnItem.value = item[option.value];\n          returnData.push(returnItem);\n        });\n      }\n    } else {\n      list.forEach((item) => {\n        const returnItem: any = {};\n        returnItem.label = item;\n        returnItem.value = item;\n        returnData.push(returnItem);\n      });\n    }\n    return returnData;\n  },\n\n  /**\n   * 求和\n   * @param nums 数组\n   * @param precision 精度\n   */\n  add(nums: number[], precision: number = 2) {\n    if (!Array.isArray(nums)) {\n      throw new Error('参数必须是数组');\n    }\n    if (nums.some(num => typeof num !== 'number')) {\n      throw new Error('数组元素必须是数字');\n    }\n    let result = 0;\n    for (const num of nums) {\n      result += num;\n    }\n    return round(result, precision);\n  },\n\n  /**\n   * 减法\n   * @param nums 数组\n   * @param precision 精度\n   */\n  subtract(nums: number[], precision: number = 2) {\n    if (!Array.isArray(nums)) {\n      throw new Error('参数必须是数组');\n    }\n    if (nums.some(num => typeof num !== 'number')) {\n      throw new Error('数组元素必须是数字');\n    }\n    if (nums.length < 2) {\n      throw new Error('减法入参数量至少要2个！');\n    }\n    let result = nums.shift();\n    for (const num of nums) {\n      result -= num;\n    }\n    return round(result, precision);\n  },\n\n  /**\n   * 乘法\n   * @param nums 数组\n   * @param precision 精度\n   */\n  multiply(nums: number[], precision: number = 2) {\n    if (!Array.isArray(nums)) {\n      throw new Error('参数必须是数组');\n    }\n    if (nums.some(num => typeof num !== 'number')) {\n      throw new Error('数组元素必须是数字');\n    }\n    let result = 1;\n    for (const num of nums) {\n      result = result * num;\n    }\n    return round(result, precision);\n  },\n\n  /**\n   * 除法\n   * @param nums 数组\n   * @param precision 精度\n   */\n  divide(nums: number[], precision: number = 2) {\n    if (!Array.isArray(nums)) {\n      throw new Error('参数必须是数组');\n    }\n    if (nums.some(num => typeof num !== 'number')) {\n      throw new Error('数组元素必须是数字');\n    }\n    if (nums.length < 2) {\n      throw new Error('除法入参数量至少要2个！');\n    }\n    let result = nums.shift();\n    for (const num of nums) {\n      if (num === 0) {\n        throw new Error('除数不能为0！');\n      }\n      result = result / num;\n    }\n    return round(result, precision);\n  }\n};\n"]}