@farris/jit-engine 1.3.58 → 1.3.62-dev2

package/lib/utility/toolhepler.js

@@ -26,99 +26,39 @@ const path = __importStar(require("path"));
 const jit_constant_1 = require("./jit-constant");
 const devkit_1 = require("./devkit");
 const logger_1 = require("./logger");
-/**
- * tf执行类型枚举
- *
- * @export
- * @enum {number}
- */
 var TfTypeEnum;
 (function (TfTypeEnum) {
     TfTypeEnum["Pascal"] = "pascal";
     TfTypeEnum["Camel"] = "camel";
 })(TfTypeEnum = exports.TfTypeEnum || (exports.TfTypeEnum = {}));
-/**
- * 工具类
- *
- * @export
- * @class ToolHelper
- */
 class ToolHelper {
-    /**
-     * 替换component中的属性名称
-     * 几种情况：
-     * 1、属性名不能以数字开头
-     * 2、属性名中间不能包含横线
-     *
-     * @static
-     * @param {string} attributeName
-     * @memberof ToolHelper
-     */
     static replaceSpecialAttributeName(attributeName) {
         return this.addWhenFirstNumber(attributeName, jit_constant_1.JITConstant.AttributeNamePrefix);
     }
     static addPrefixWhenFirstNumber(source) {
         return this.addWhenFirstNumber(source, jit_constant_1.JITConstant.FirstNumberPrefix);
     }
-    /**
-     * 如果首字母为数字 那么增加固定字符串前缀
-     *
-     * @static
-     * @param {string} source
-     * @param {string} addValue
-     * @returns
-     * @memberof ToolHelper
-     */
     static addWhenFirstNumber(source, addValue) {
         if (!source) {
             return source;
         }
-        // 判断字符串首字母为数字
         if (this.isFirstNumber(source)) {
             source = addValue + source;
         }
-        // 替换特殊字符 .-_
         return source;
     }
-    /**
-     * 判断字符串是否以数字开头
-     *
-     * @static
-     * @param {string} source 源字符串
-     * @returns
-     * @memberof ToolHelper
-     */
     static isFirstNumber(source) {
         const reg = new RegExp("^[0-9]+.*");
         return reg.test(source);
     }
-    /**
-     * null或undefined 转换成为空字符串
-     *
-     * @param {string} source
-     * @returns {string}
-     * @memberof AbstractTemplateGenerator
-     */
     static convertNullToEmpty(source, defaultValue = "") {
         if (!source) {
             return defaultValue;
         }
         return source;
     }
-    /**
-     * 根据Dom类型构造
-     *
-     * @static
-     * @param {string} type dom类型
-     * @param i18nResourcePrefix
-     * @param externalComponentNameSpace
-     * @param viewModel
-     * @returns
-     * @member ToolHelper
-     */
     static createObjectByType(type, i18nResourcePrefix, externalComponentNameSpace, viewModel) {
         const dom = Dom;
-        // tslint:disable-next-line:no-eval
         const domValue = eval(`dom.${type}`);
         if (domValue) {
             domValue["resourcePrefix"] = i18nResourcePrefix;
@@ -127,23 +67,11 @@ class ToolHelper {
         }
         return domValue;
     }
-    /**
-     * 获取对象对应的类型
-     *
-     * @static
-     * @param {*} obj 具体对象值
-     * @returns
-     * @memberof ToolHelper
-     */
     static getClassName(obj) {
         const undefinedResult = "undefined";
         if (!obj || !obj.constructor) {
             return undefinedResult;
         }
-        /*
-         * for browsers which have name property in the constructor
-         * of the object,such as chrome
-         */
         if (obj.constructor.name) {
             return obj.constructor.name;
         }
@@ -151,20 +79,11 @@ class ToolHelper {
         if (!str) {
             return undefinedResult;
         }
-        /*
-         * executed if the return of object.constructor.toString() is
-         * "[object objectClass]"
-         */
         let arr;
         if (str.charAt(0) == '[') {
             arr = str.match(/\[\w+\s*(\w+)\]/);
         }
         else {
-            /*
-             * executed if the return of object.constructor.toString() is
-             * "function objectClass () {}"
-             * for IE Firefox
-             */
             arr = str.match(/function\s*(\w+)/);
         }
         if (arr && arr.length == 2) {
@@ -172,12 +91,6 @@ class ToolHelper {
         }
         return undefinedResult;
     }
-    /**
-     * 判断一个对象是否是数组
-     * 如果长度为0，是否认为是数组。true 认为是数组，默认为false,长度为0，不认为是数组
-     * @param obj 待判断的对象
-     * @param includeLengthZero 如果长度为0，是否认为是数组。true 认为是数组，默认为false,长度为0，不认为是数组
-     */
     static isArray(obj, includeLengthZero = false) {
         let isArray = Array.isArray(obj);
         if (isArray && includeLengthZero === false) {
@@ -187,10 +100,6 @@ class ToolHelper {
         }
         return isArray;
     }
-    /**
-     * 字符串转驼峰 且其中-横线 下划线移除 后续的字母转换成大写形式
-     * @param str 需要转换的字符串
-     */
     static tf(str, type = TfTypeEnum.Pascal) {
         if (!str) {
             return;
@@ -202,40 +111,18 @@ class ToolHelper {
             return name.toUpperCase();
         });
     }
-    /**
-     * 替换特殊字符
-     *
-     * @static
-     * @param {string} source
-     * @returns {string}
-     * @memberof ToolHelper
-     */
     static replaceSpecialCharacter(source) {
         if (!source) {
             return '';
         }
         return source.replace(/[-_.]/g, "");
     }
-    /**
-     * 点号替换成下划线
-     *
-     * @static
-     * @param {string} source
-     * @returns {string}
-     * @memberof ToolHelper
-     */
     static replaceDotToXiaHuaXian(source) {
         if (!source) {
             return '';
         }
         return source.replace(/\./g, "_");
     }
-    /**
-     *  字符串替换
-     * @param source 源字符串
-     * @param targetValue 目标字符串
-     * @param isReplaceAll 是否全局替换
-     */
     static replaceAll(source, replacedValue, targetValue, replaceAll) {
         if (!source) {
             return '';
@@ -243,15 +130,8 @@ class ToolHelper {
         if (replaceAll) {
             return source.replace(new RegExp(replacedValue, "g"), targetValue);
         }
-        // const replacedVVV = _.escapeRegExp(replacedValue);
-        // let mmm = _.replace(_.escapeRegExp(source), replacedVVV, targetValue);
         return source.replace(replacedValue, targetValue);
-        // return _.replace(source, replacedValue, targetValue);
     }
-    /**
-     * 将字符串双引号更改成为单引号
-     * @param source
-     */
     static replaceQuoteToSingle(source) {
         if (this.isNullOrUndefined(source) || this.isString(source) == false) {
             return source;
@@ -260,12 +140,6 @@ class ToolHelper {
         result = this.replaceString(result, "\"", "'");
         return result;
     }
-    /**
-     * 采用npm包 path-string的字符串替换
-     * @param string
-     * @param needle
-     * @param replacement
-     */
     static replaceString(string, needle, replacement) {
         if (typeof string !== 'string') {
             throw new TypeError(`Expected input to be a string, got ${typeof string}`);
@@ -280,14 +154,13 @@ class ToolHelper {
         if (prevIndex > string.length) {
             return string;
         }
-        while (true) { // eslint-disable-line no-constant-condition
+        while (true) {
             const index = string.indexOf(needle, prevIndex);
             if (index === -1) {
                 break;
             }
             matchCount++;
             const replaceStr = replacement;
-            // Get the initial part of the string on the first iteration.
             const beginSlice = matchCount === 1 ? 0 : prevIndex;
             result += string.slice(beginSlice, index) + replaceStr;
             prevIndex = index + needle.length;
@@ -297,56 +170,24 @@ class ToolHelper {
         }
         return result + string.slice(prevIndex);
     }
-    /**
-     * 横线替换成下划线
-     *
-     * @static
-     * @param {string} source
-     * @returns {string}
-     * @memberof ToolHelper
-     */
     static replaceHengXianToXiaHuaXian(source) {
         if (!source) {
             return '';
         }
         return source.replace(/\-/g, "_");
     }
-    /**
-     * 横线和点号替换成下划线
-     *
-     * @static
-     * @param {string} source
-     * @returns {string}
-     * @memberof ToolHelper
-     */
     static replaceHengXianAndDotToXiaHuaXian(source) {
         if (!source) {
             return '';
         }
         return source.replace(/[-.]/g, "_");
     }
-    /**
-     * 判断大小写
-     * @param ch 参数
-     */
     static isUpper(ch) {
         return ch >= 'A' && ch <= 'Z';
     }
-    /**
-     *
-     *
-     * @static
-     * @param {*} ch
-     * @returns
-     * @memberof ToolHelper
-     */
     static isSpace(ch) {
         return /\s+/.test(ch);
     }
-    /**
-     * 首字母转换成小写形式
-     * @param s 参数
-     */
     static toCamelCase(s) {
         if (!s || !this.isUpper(s[0])) {
             return s;
@@ -367,55 +208,24 @@ class ToolHelper {
         }
         return chars.join('');
     }
-    /**
-     * 将字符串转换成小写形式
-     *
-     * @static
-     * @param {string} source
-     * @memberof ToolHelper
-     */
     static toLowerCase(source) {
         if (!source) {
             return "";
         }
         return source.toLowerCase();
     }
-    /**
-     * 字符串两端增加单引号
-     *
-     * @static
-     * @param {string} source
-     * @returns {string}
-     * @memberof ToolHelper
-     */
     static addDotBothAndEnd(source) {
         if (source) {
             return `'${source}'`;
         }
         return null;
     }
-    /**
-     * null 或undefined 转换成空字符串
-     *
-     * @static
-     * @param {*} source
-     * @memberof ToolHelper
-     */
     static nullConvertToEmpty(source) {
         if (!source) {
             return "";
         }
         return source;
     }
-    /**
-     * 合并并美化路径
-     *
-     * @static
-     * @param {string} path1 路径1
-     * @param {string} path2 路径2
-     * @returns
-     * @memberof ToolHelper
-     */
     static pathJoinAndnormalize(path1, path2) {
         if (!path1 && !path2) {
             return;
@@ -428,87 +238,35 @@ class ToolHelper {
         }
         return path.normalize(path.join(path1, path2));
     }
-    /**
-     * 判断路径是否是绝对路径
-     *
-     * @static
-     * @param {string} pathParameter 路径参数
-     * @memberof ToolHelper
-     */
     static isAbsolutePath(pathParameter) {
         if (!pathParameter) {
             return false;
         }
         return path.isAbsolute(pathParameter);
     }
-    /**
-     * 反斜杠转换成斜杠  应用于windows 及linux环境下
-     *
-     * @static
-     * @param {string} sourcePath
-     * @memberof ToolHelper
-     */
     static BackslashToSlash(sourcePath) {
         if (sourcePath) {
             return String.raw `${sourcePath}`.split('\\').join('/');
         }
     }
-    /**
-     * 判断值是否是字符串
-     *
-     * @static
-     * @param {*} source
-     * @memberof ToolHelper
-     */
     static isString(source) {
         return typeof (source) == 'string';
     }
-    /**
-     * 判断传递参数是否是数字类型
-     * @param source 源数据
-     * @returns 是否数字
-     */
     static isNumber(source) {
         if (source === "" || source == null) {
             return false;
         }
         if (!isNaN(source)) {
-            // 对于空数组和只有一个数值成员的数组或全是数字组成的字符串，isNaN返回false，例如：'123'、[]、[2]、['123'],isNaN返回false,
-            // 所以如果不需要val包含这些特殊情况，则这个判断改写为if(!isNaN(val) && typeof val === 'number' )
             return true;
         }
         return false;
     }
-    /**
-     * 判断字符串是否是函数
-     *
-     * @static
-     * @param {*} source
-     * @returns
-     * @memberof ToolHelper
-     */
     static isFunction(source) {
         return typeof source === 'function';
     }
-    /**
-     * 判断是null或undefined
-     *
-     * @static
-     * @param {*} source
-     * @returns
-     * @memberof ToolHelper
-     */
     static isNullOrUndefined(source) {
         return source === undefined || source === null;
     }
-    /**
-     * 判断是否是null或undefined  或如果为字符串，判断是否为空字符串
-     *
-     * @static
-     * @param {*} source
-     * @returns
-     * @memberof ToolHelper
-     */
     static isNullOrUndefinedOrEmpty(source) {
         if (this.isNullOrUndefined(source)) {
             return true;
@@ -518,55 +276,29 @@ class ToolHelper {
         }
         return false;
     }
-    /**
-     * 判断一个参数值是否为boolean型
-     *
-     * @static
-     * @param {*} source
-     * @memberof ToolHelper
-     */
     static isBoolean(source) {
         return typeof (source) === 'boolean';
     }
-    /**
-     * 判断值是否是对象
-     *
-     * @static
-     * @param {*} source
-     * @memberof ToolHelper
-     */
     static isObject(source) {
         return typeof (source) == 'object';
     }
-    /**
-     * 创建对应的readonly值
-     *
-     * @static
-     * @param {*} readonlyValue
-     * @memberof ToolHelper
-     */
     static createReadonlyState(readonlyValue) {
         if (ToolHelper.isNullOrUndefined(readonlyValue)) {
             return false;
         }
-        // 如果值为boolean
         if (ToolHelper.isBoolean(readonlyValue)) {
             return readonlyValue;
         }
         if (readonlyValue.value == true || readonlyValue.value == false) {
             return readonlyValue.value;
         }
-        // 表示 绑定了变量
         if (readonlyValue.type == "Variable") {
             return readonlyValue.value;
         }
-        // 表示为非变量的字符串  为状态机
         if (ToolHelper.isString(readonlyValue)) {
             if (readonlyValue.indexOf("=>") >= 0) {
-                // 表示为自定义函数 不进行任何处理
             }
             else {
-                // 进行了两次替换 避免出现this.viewModel 再次进行替换的情况
                 readonlyValue = readonlyValue.replace("this.viewModel", "viewModel").replace("viewModel", "this.viewModel");
             }
             return readonlyValue;
@@ -576,35 +308,23 @@ class ToolHelper {
         }
         return readonlyValue.value;
     }
-    /**
-     * 创建对应的visible值
-     *
-     * @static
-     * @param {*} visibleValue
-     * @memberof ToolHelper
-     */
     static createVisibleState(visibleValue) {
         if (ToolHelper.isNullOrUndefined(visibleValue)) {
             return true;
         }
-        // 如果值为boolean
         if (ToolHelper.isBoolean(visibleValue)) {
             return visibleValue;
         }
         if (visibleValue.value == true || visibleValue.value == false) {
             return visibleValue.value;
         }
-        // 表示 绑定了变量
         if (visibleValue.type == "Variable") {
             return visibleValue.value;
         }
-        // 表示为非变量的字符串  为状态机
         if (ToolHelper.isString(visibleValue)) {
             if (visibleValue.indexOf("=>") >= 0) {
-                // 表示为自定义函数 不进行任何处理
             }
             else {
-                // 进行了两次替换 避免出现this.viewModel 再次进行替换的情况
                 let strVisibleValue = visibleValue.toString();
                 strVisibleValue = this.viewModelReplaceToThisViewModel(strVisibleValue);
                 return strVisibleValue;
@@ -618,10 +338,6 @@ class ToolHelper {
         }
         return visibleValue.value;
     }
-    /**
-     * viewModel替换成this.viewModel
-     * @param source viewModel
-     */
     static viewModelReplaceToThisViewModel(source) {
         if (!source) {
             return source;
@@ -631,81 +347,39 @@ class ToolHelper {
         strVisibleValue = ToolHelper.replaceAll(strVisibleValue, "viewModel", "this.viewModel", true);
         return strVisibleValue;
     }
-    /**
-     * 将字符串中的反斜线转换成斜线
-     * @param source
-     */
     static replaceFanXieXianToXieXian(source) {
         if (this.isNullOrUndefined(source)) {
             return source;
         }
         return source.replace(/\\/g, "/");
     }
-    /**
-     *  获取当前时间的整数形式
-     */
     static getCurrentTimeNumber() {
         return new Date().getTime().toString();
     }
-    /**
-     * 字符串转boolean
-     * 如果源为null或undefined  那么返回默认值
-     *
-     * @static
-     * @param {(string | boolean)} source
-     * @param {boolean} [defaultValue=false]
-     * @returns
-     * @memberof ToolHelper
-     */
     static convertStringToBoolean(source, defaultValue = false) {
         if (this.isNullOrUndefined(source)) {
             return defaultValue;
         }
-        // 如果源是bool型的参数
         if (typeof source === "boolean") {
             return source;
         }
-        // 如果是字符串true  或字符串false  那么进行下转换
         if (typeof source === "string" && source.trim().toLowerCase() == "true") {
             return true;
         }
-        // 其他类型的均转换成false
         return false;
     }
-    /**
-     * 如果第一个参数为空，那么使用第二个参数
-     * 如果第一个参数不为空，那么使用第一个参数
-     * @param source 第一个参数
-     * @param target  第二个参数
-     */
     static useSecondIfFirstIsNull(source, target) {
         if (this.isNullOrUndefined(source)) {
             return target;
         }
         return source;
     }
-    /**
-     * 字符串转换成JSON
-     *
-     * @static
-     * @param {string} source
-     * @memberof ToolHelper
-     */
     static convertToJSON(source) {
         if (source) {
             return JSON.parse(source);
         }
         return source;
     }
-    /**
-     * 转换字符串为JSON格式
-     *
-     * @static
-     * @param {string} source 源数据
-     * @param {*} [defaultJson={}] 默认的返回json数据
-     * @returns
-     * @memberof ToolHelper
-     */
     static convertToJsonOrDefault(source, defaultJson = {}) {
         if (source) {
             try {
@@ -717,50 +391,17 @@ class ToolHelper {
         }
         return defaultJson;
     }
-    /**
-     * 判断是否以指定字符结尾
-     *
-     * @static
-     * @param {string} str
-     * @param {string} target
-     * @returns
-     * @memberof ToolHelper
-     */
     static confirmEnding(str, target) {
-        // 请把你的代码写在这里
         const start = str.length - target.length;
         const arr = str.substr(start, target.length);
         return arr == target;
     }
-    /**
-     * 创建binging参数 如果参数为null  那么使用默认值
-     *
-     * @static
-     * @param {*} parameter
-     * @param {*} defaultValue
-     * @returns {Binding}
-     * @memberof ToolHelper
-     */
     static createBinding(parameter, defaultValue, externalComponentNameSpace) {
         return this.createBindingWithPosition(parameter, defaultValue, externalComponentNameSpace, null);
     }
-    /**
-     *  不包含默认值的binding构造
-     * @param parameter 参数信息
-     * @param externalComponentNameSpace  扩展组件namespace
-     * @returns binding实例
-     */
     static createBindingWithoutDefaultValue(parameter, externalComponentNameSpace) {
         return this.createBinding(parameter, null, externalComponentNameSpace);
     }
-    /**
-     *  使用包含具体位置的binding  主要和使用表达式场景有关
-     * @param parameter 参数信息
-     * @param defaultValue 默认值
-     * @param externalComponentNameSpace 扩展信息namespace
-     * @param runningPosition 运行位置
-     * @returns binding实例
-     */
     static createBindingWithPosition(parameter, defaultValue, externalComponentNameSpace, runningPosition) {
         let result;
         if (this.isNullOrUndefined(parameter)) {
@@ -783,15 +424,10 @@ class ToolHelper {
         }
         return binding;
     }
-    /**
-     *
-     * @param value 绑定是否必填
-     */
     static isRequireWithBinding(value) {
         if (!value || this.isBinding(value) == false) {
             return false;
         }
-        // 如果是boolean  那么直接返回
         if (this.isBoolean(value.value)) {
             return value.value;
         }
@@ -806,69 +442,58 @@ class ToolHelper {
             return false;
         return value.value;
     }
-    /**
-     *
-     * @param value 判断绑定是否是Expression
-     * @returns
-     */
     static isExpression(value) {
         if (!value || this.isBinding(value) == false) {
             return false;
         }
         return value.isExpression;
     }
-    /**
-     *
-     * @param value 判断是否是变量
-     * @returns
-     */
     static isVariable(value) {
         if (!value || this.isBinding(value) == false) {
             return false;
         }
         return value.isVariable;
     }
-    /**
-     *
-     * @param value 判断绑定是否form
-     * @returns
-     */
     static isForm(value) {
         if (!value || this.isBinding(value) == false) {
             return false;
         }
         return value.isForm;
     }
-    /**
-     *
-     * @param value 判断参数值是否是Binding类型
-     * @returns
-     */
     static isBinding(value) {
         if (!value) {
             return false;
         }
         return value instanceof domstructure_1.Binding;
     }
-    /**
-     *
-     * @returns
-     * @param val
-     */
     static isDef(val) {
         return val !== undefined && val !== null;
     }
-    /**
-     * 判断是否以制定字符开头
-     * @param startWithParameter
-     * @param source
-     */
     static startWith(startWithParameter, source) {
         if (!source || !startWithParameter) {
             return false;
         }
         return source.startsWith(startWithParameter);
     }
+    static generateNgStyle(styleValue) {
+        if (styleValue) {
+            let generateString = "";
+            generateString += "{";
+            const stepStyleArr = styleValue.split(";");
+            if (ToolHelper.isArray(stepStyleArr, false)) {
+                stepStyleArr.forEach((styleItem, index) => {
+                    const styleItemSplitArr = styleItem.split(":");
+                    if (ToolHelper.isArray(styleItemSplitArr, false) && styleItemSplitArr.length == 2) {
+                        generateString += `'${styleItemSplitArr[0]}':'${styleItemSplitArr[1]}'`;
+                        if (index < stepStyleArr.length - 1) {
+                            generateString += ",";
+                        }
+                    }
+                });
+            }
+            generateString += "}";
+            return generateString;
+        }
+    }
 }
 exports.ToolHelper = ToolHelper;
-//# sourceMappingURL=toolhepler.js.map