加密Util

mk_framework/assets/script/mk/utils/EncryptUtil.ts

@@ -2,20 +2,24 @@ import { hmacSha256 } from "./encrypt/hmacSha256"
 import * as CryptoJS from "./encrypt/aes.js"
 
 /**
- * 工具类
+ * 加密解密工具类
+ * @author zy
  */
 export class EncryptUtil {
 
-    // 随机生成32位字符串
-    static randomString(len = 32) {
-        let $chars =
-            'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678'
-        let maxPos = $chars.length
-        let pwd = ''
+    /**
+     * 随机生成多位位字符串
+     * @param   len    字符串长度
+     * @returns 
+     */
+    public randomString(len = 32) {
+        let $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnoprstuvwxyz123456789';
+        let maxPos = $chars.length;
+        let pwd = '';
         for (let i = 0; i < len; i++) {
             pwd += $chars.charAt(Math.floor(Math.random() * maxPos))
         }
-        return pwd
+        return pwd;
     }
 
     //说明：
@@ -25,26 +29,39 @@ export class EncryptUtil {
     //  4.AES的密钥长度有三种（128,192,256，默认是128），所以也要和后端保持一致
     //  5.AES的加密结果编码方式有两种（base64和十六进制），具体怎么选择由自己定，但是加密和解密的编码方式要统一
     //十六位十六进制数作为秘钥
-    // private static key = fun_aes.CryptoJS.enc.Utf8.parse("3454345434543454");
+    // private public key = fun_aes.CryptoJS.enc.Utf8.parse("3454345434543454");
     //十六位十六进制数作为秘钥偏移量
-    // private static iv = fun_aes.CryptoJS.enc.Utf8.parse('6666666666666666');
-
-    /**aes加密
-     * @param state true 存包长 false /r/n
+    // private public iv = fun_aes.CryptoJS.enc.Utf8.parse('6666666666666666');
+
+    /**
+     * 说明：
+     * 1.如果加密解密涉及到前端和后端，则这里的key要保持和后端的key一致
+     * 2.AES的算法模式有好几种（ECB,CBC,CFB,OFB），所以也要和后端保持一致
+     * 3.AES的补码方式有两种（PKS5，PKS7），所以也要和后端保持一致
+     * 4.AES的密钥长度有三种（128,192,256，默认是128），所以也要和后端保持一致
+     * 5.AES的加密结果编码方式有两种（base64和十六进制），具体怎么选择由自己定，但是加密和解密的编码方式要统一
+     * 十六位十六进制数作为秘钥
+     * private public key = fun_aes.CryptoJS.enc.Utf8.parse("3454345434543454");
+     * 十六位十六进制数作为秘钥偏移量
+     * private public iv = fun_aes.CryptoJS.enc.Utf8.parse('6666666666666666');
+     * 
+     * aes加密
+     * @param   word    需要加密的字符串
+     * @param   tkey    加密key，一般为sessionkey
+     * @param   appid   游戏的appid
+     * @param   state   true 存包长 false /r/n
+     * @returns 
     */
-    static Encrypt(word, tkey, appid, state = true) {
-        let tiv = tkey.substr(0, 16)
+    public encrypt(word, tkey, appid, state = true) {
+        let tiv = tkey.substr(0, 16);
 
-        // n = Base64.Instance.encode(n)
         //明文拼接
-        let newStr = ''
+        let newStr = '';
         if (state) {
-            // let n = this.pack(word.length)
-            // newStr = tiv + n + word + appid
-            newStr = tiv + word + appid
+            newStr = tiv + word + appid;
         }
         else {
-            newStr = tiv + word + '\r\n' + appid
+            newStr = tiv + word + '\r\n' + appid;
         }
 
         //加密后
@@ -52,68 +69,93 @@ export class EncryptUtil {
         let iv = CryptoJS.enc.Utf8.parse(tiv);
 
         newStr = CryptoJS.enc.Utf8.parse(newStr);
-        var encrypted = CryptoJS.AES.encrypt(newStr, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
-        encrypted = encrypted.toString()
-        let mac = hmacSha256.Instance.hex_hmac_sha256(tkey, encrypted)
-        let newStrTwo = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(tiv + encrypted + mac));
-        return newStrTwo
+        let encrypted = CryptoJS.AES.encrypt(newStr, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
+        encrypted = encrypted.toString();
+        let mac = hmacSha256.Instance.hex_hmac_sha256(tkey, encrypted);
+        return CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(tiv + encrypted + mac));
     }
-    /** aes解密
-    * @param state true 存包长 false /r/n
-    */
-    static Decrypt(word, tkey, appid, state = true) {
 
+    /**
+     * aes解密
+     * @param   word    需要加密的字符串
+     * @param   tkey    加密key，一般为sessionkey
+     * @param   appid   游戏的appid
+     * @param   state   true 存包长 false /r/n
+     * @returns 
+     */
+    public decrypt(word, tkey, appid, state = true) {
         let en = CryptoJS.enc.Base64.parse(word).toString(CryptoJS.enc.Utf8);
-        let newStrOne = en.substr(16)
-        let temp = newStrOne.substr(0, newStrOne.length - 64)
-        let de = temp
+        let newStrOne = en.substr(16);
+        let temp = newStrOne.substr(0, newStrOne.length - 64);
+        let de = temp;
 
         let key = CryptoJS.enc.Utf8.parse(tkey);
         let iv = CryptoJS.enc.Utf8.parse(tkey.substr(0, 16));
 
-        var decrypt = CryptoJS.AES.decrypt(de, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
-        // LogUtil.log('decrypt   ', decrypt)
-        var decryptedStr = CryptoJS.enc.Utf8.stringify(decrypt)
-        decryptedStr = decryptedStr.toString()
+        let decrypt = CryptoJS.AES.decrypt(de, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
+        let decryptedStr = CryptoJS.enc.Utf8.stringify(decrypt);
+        decryptedStr = decryptedStr.toString();
 
-        // LogUtil.log('decryptedStr   ', decryptedStr)
-        let newStrThree = ''
+        let newStrThree = '';
         if (state) {
-            newStrThree = decryptedStr.slice(16).replace(new RegExp("(.*)" + appid), '$1')
+            newStrThree = decryptedStr.slice(16).replace(new RegExp("(.*)" + appid), '$1');
         }
         else {
-            newStrThree = decryptedStr.slice(16).split('\r\n')[0]
+            newStrThree = decryptedStr.slice(16).split('\r\n')[0];
         }
-        return newStrThree
+        return newStrThree;
     }
 
-    /** for php pack( N , length ) */
-    static pack(len: number) {
-        var buf: ArrayBuffer = new ArrayBuffer(4);
-        var dataView = new DataView(buf);
-        dataView.setUint32(0, len)
-        // LogUtil.log('dataView  ', dataView)
-        let str2 = this.ab2str(buf)
-
-        // let utf8decoder = new TextDecoder();
-        // let str2 = utf8decoder.decode(buf)
-        // LogUtil.log('str2  ', str2)
-
-        // let utf8encoder = new TextEncoder();
-        // let str3 = utf8encoder.encode(str2)
-        // LogUtil.log("str3:", str3)
+    private options = {
+        default_key_size: 2048,
+        default_public_exponent: new Uint8Array([0x01, 0x00, 0x01])
+    }
+    /**
+     * rsa加密
+     * @param   word        需要加密的字符串
+     * @param   isLong      字符串加长版
+     * @returns 
+     */
+    public rsaEncrypt(word, isLong: boolean = false) {
+        let jsb = new window['JSEncrypt'](this.options);
 
-        // let str4 = utf8decoder.decode(str3)
-        // LogUtil.log('str4  ', str4)
+        //公钥
+        let publicString = '-----BEGIN PUBLIC KEY-----\n' +
+            'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuwz5V8wt525dMS+A9wOd\n' +
+            'NAjvKgxdyoXYuZSlAJEXLhvJlaXwFCKEsUg/qBBeo4nrRnwaFAjG7ItqbCWR9Ozv\n' +
+            '6oY5tMYQnFFK82XkMGbKm1gG0z9vYKhcNYgHZHi+QKAw4tLLWXWO/QBTGelEXptD\n' +
+            'azlNmdM+8wHOknTcMuIyjc9Yo5qCoNsCJpA465vnREiBezBbKB3rSw+LmrRcZcFk\n' +
+            's8hmGtjpabcQ8sCxco7mRzVh6/DomNWfNm7hUP6shrrJirwjQtaS51grlScj8KhN\n' +
+            'h+kBoiI4Ad0Xz0GHasK5hAMf3sXDsN61r0An8KTfa/nsYSJDwogPIKkeKAsmw9Df\n' +
+            'EQIDAQAB\n' +
+            '-----END PUBLIC KEY-----'
+        jsb.setPublicKey(publicString);
+        // 加密内容
+        let encrypted = isLong ? jsb.encryptLong(word) : jsb.encrypt(word);
+        return encrypted;
+    }
 
-        // let aa = fun_aes.CryptoJS.enc.Utf8.parse(str2)
-        // LogUtil.log('aa  ', aa)
-        return str2
+    /**
+     * for php pack( N , length )
+     * @param   len    
+     * @returns 
+     */
+    public pack(len: number) {
+        let buf: ArrayBuffer = new ArrayBuffer(4);
+        let dataView = new DataView(buf);
+        dataView.setUint32(0, len);
+        let str2 = this.ab2str(buf);
+        return str2;
     }
 
-    static Utf8ArrayToStr(array) {
-        var out, i, len, c;
-        var char2, char3;
+    /**
+     * 
+     * @param array 
+     * @returns 
+     */
+    public utf8ArrayToStr(array) {
+        let out, i, len, c;
+        let char2, char3;
 
         out = "";
         len = array.length;
@@ -144,13 +186,17 @@ export class EncryptUtil {
         return out;
     }
 
-    //UTF-16转UTF-8
-    static utf16ToUtf8(s) {
+    /**
+     * UTF-16转UTF-8
+     * @param   s 
+     * @returns 
+     */
+    public utf16ToUtf8(s) {
         if (!s) {
             return;
         }
 
-        var i, code, ret = [], len = s.length;
+        let i, code, ret = [], len = s.length;
         for (i = 0; i < len; i++) {
             code = s.charCodeAt(i);
             if (code > 0x0 && code <= 0x7f) {
@@ -185,13 +231,18 @@ export class EncryptUtil {
 
         return ret.join('');
     }
-    //UTF-8转UTF-16
-    static utf8ToUtf16(s) {
+
+    /**
+     * UTF-8转UTF-16
+     * @param s 
+     * @returns 
+     */
+    public utf8ToUtf16(s) {
         if (!s) {
             return;
         }
 
-        var i, codes, bytes, ret = [], len = s.length;
+        let i, codes, bytes, ret = [], len = s.length;
         for (i = 0; i < len; i++) {
             codes = [];
             codes.push(s.charCodeAt(i));
@@ -218,127 +269,56 @@ export class EncryptUtil {
         return ret.join('');
     }
 
-    // ArrayBuffer转为字符串，参数为ArrayBuffer对象
-    static ab2str(buf: ArrayBuffer) {
+    /**
+     * ArrayBuffer转为字符串，参数为ArrayBuffer对象
+     * @param buf 
+     * @returns 
+     */
+    public ab2str(buf: ArrayBuffer) {
         return String.fromCharCode.apply(null, new Uint8Array(buf));
     }
 
-
-    static Uint8ArrayToString(fileData) {
-        var dataString = "";
-        for (var i = 0; i < fileData.length; i++) {
+    /**
+     * 
+     * @param fileData 
+     * @returns 
+     */
+    public uint8ArrayToString(fileData) {
+        let dataString = "";
+        for (let i = 0; i < fileData.length; i++) {
             dataString += String.fromCharCode(fileData[i]);
         }
 
         return dataString
     }
 
-    static stringToUint8Array(str) {
-        var arr = [];
-        for (var i = 0, j = str.length; i < j; ++i) {
+    /**
+     * 
+     * @param str 
+     * @returns 
+     */
+    public stringToUint8Array(str) {
+        let arr = [];
+        for (let i = 0, j = str.length; i < j; ++i) {
             arr.push(str.charCodeAt(i));
         }
 
-        var tmpUint8Array = new Uint8Array(arr);
+        let tmpUint8Array = new Uint8Array(arr);
         return tmpUint8Array
     }
 
-    // 字符串转为ArrayBuffer对象，参数为字符串
-    static str2ab(str) {
-        var buf = new ArrayBuffer(str.length); // 每个字符占用2个字节
-        var bufView = new Uint8Array(buf);
-        for (var i = 0, strLen = str.length; i < strLen; i++) {
+    /**
+     * 字符串转为ArrayBuffer对象，参数为字符串
+     * @param str 
+     * @returns 
+     */
+    public str2ab(str) {
+        let buf = new ArrayBuffer(str.length); // 每个字符占用2个字节
+        let bufView = new Uint8Array(buf);
+        for (let i = 0, strLen = str.length; i < strLen; i++) {
             bufView[i] = str.charCodeAt(i);
         }
         return buf;
     }
 
-    private static options = {
-        default_key_size: 2048,
-        default_public_exponent: new Uint8Array([0x01, 0x00, 0x01])
-    }
-
-    /*rsa加密*/
-    static RSAEncrypt(word) {
-        //LogUtil.log("JSEncrypt",window['JSEncrypt'])
-        let jsb = new window['JSEncrypt'](this.options)
-
-        //公钥
-        var publicString = '-----BEGIN PUBLIC KEY-----\n' +
-            'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuwz5V8wt525dMS+A9wOd\n' +
-            'NAjvKgxdyoXYuZSlAJEXLhvJlaXwFCKEsUg/qBBeo4nrRnwaFAjG7ItqbCWR9Ozv\n' +
-            '6oY5tMYQnFFK82XkMGbKm1gG0z9vYKhcNYgHZHi+QKAw4tLLWXWO/QBTGelEXptD\n' +
-            'azlNmdM+8wHOknTcMuIyjc9Yo5qCoNsCJpA465vnREiBezBbKB3rSw+LmrRcZcFk\n' +
-            's8hmGtjpabcQ8sCxco7mRzVh6/DomNWfNm7hUP6shrrJirwjQtaS51grlScj8KhN\n' +
-            'h+kBoiI4Ad0Xz0GHasK5hAMf3sXDsN61r0An8KTfa/nsYSJDwogPIKkeKAsmw9Df\n' +
-            'EQIDAQAB\n' +
-            '-----END PUBLIC KEY-----'
-        jsb.setPublicKey(publicString)
-        // 加密内容
-        let encrypted = jsb.encrypt(word)
-        return encrypted
-    }
-
-    static RSAEncryptLong(word) {
-        // console.log(window['JSEncrypt'])
-        let jsb = new window['JSEncrypt'](this.options);
-
-        //公钥
-        var publicString = '-----BEGIN PUBLIC KEY-----\n' +
-            'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuwz5V8wt525dMS+A9wOd\n' +
-            'NAjvKgxdyoXYuZSlAJEXLhvJlaXwFCKEsUg/qBBeo4nrRnwaFAjG7ItqbCWR9Ozv\n' +
-            '6oY5tMYQnFFK82XkMGbKm1gG0z9vYKhcNYgHZHi+QKAw4tLLWXWO/QBTGelEXptD\n' +
-            'azlNmdM+8wHOknTcMuIyjc9Yo5qCoNsCJpA465vnREiBezBbKB3rSw+LmrRcZcFk\n' +
-            's8hmGtjpabcQ8sCxco7mRzVh6/DomNWfNm7hUP6shrrJirwjQtaS51grlScj8KhN\n' +
-            'h+kBoiI4Ad0Xz0GHasK5hAMf3sXDsN61r0An8KTfa/nsYSJDwogPIKkeKAsmw9Df\n' +
-            'EQIDAQAB\n' +
-            '-----END PUBLIC KEY-----'
-        jsb.setPublicKey(publicString);
-        // 加密内容
-        let encrypted = jsb.encryptLong(word);
-        return encrypted;
-    }
-
-    /*rsa解密*/
-    // static RSADecrypt(word) {
-    //     // LogUtil.log(window['JSEncrypt'])
-    //     let jsb = new JSEncrypt(this.options)
-
-    //     //私钥
-    //     var privateString = '-----BEGIN RSA PRIVATE KEY-----\n' +
-    //         'MIIEowIBAAKCAQEAuwz5V8wt525dMS+A9wOdNAjvKgxdyoXYuZSlAJEXLhvJlaXw\n' +
-    //         'FCKEsUg/qBBeo4nrRnwaFAjG7ItqbCWR9Ozv6oY5tMYQnFFK82XkMGbKm1gG0z9v\n' +
-    //         'YKhcNYgHZHi+QKAw4tLLWXWO/QBTGelEXptDazlNmdM+8wHOknTcMuIyjc9Yo5qC\n' +
-    //         'oNsCJpA465vnREiBezBbKB3rSw+LmrRcZcFks8hmGtjpabcQ8sCxco7mRzVh6/Do\n' +
-    //         'mNWfNm7hUP6shrrJirwjQtaS51grlScj8KhNh+kBoiI4Ad0Xz0GHasK5hAMf3sXD\n' +
-    //         'sN61r0An8KTfa/nsYSJDwogPIKkeKAsmw9DfEQIDAQABAoIBAFonN6pkY5+O5uXE\n' +
-    //         '8pCbslIZGESY7z+kYT+Y8CokxBpaFD/HWb4qoO/dVakIMsT5vWcce2k6jb4GuAVl\n' +
-    //         '2kJFTKEpjnidmfXtjIVhj6jwciiLNcbtZR4eJ0s5w+5d77ywOL+qP45fhcpVNLhh\n' +
-    //         'YK2EgesVFFzWnxl6vniCUHtJ4HnOKHJCnLNP8Jv7v8yWqRhdPv+OSnXc/f8M5Nq4\n' +
-    //         'zXIjZIf84sQdI9MAZ4IUv3yUnhQIGCX/ilLiOb+u8Z02DnImpwrSurm4SWOl/W7F\n' +
-    //         'jz1LHonOnFNvoICwJUlwmSHVbSxOG4dHSxs45dSHizCxIbPyHNW0sF/u5EHz2cmw\n' +
-    //         'ZIrtmh0CgYEA91DZBmRS8f6ELIPTozOd9c9OOiW0Mn0njG2Hf59tRkUNcAVnrdT6\n' +
-    //         '1v0ziD1tnprBCQr7NKzJiU3ds4qR/Vfza2F9M894CIX3HZLZomrP+Kr0xqeogxfy\n' +
-    //         'IVQ3n6aCIR2lKG2zBuxJJCp3UhGjS1NOOvcVqK9F+0Py6LHRG7SAoMsCgYEAwZ5l\n' +
-    //         'Q2x/V9vDf3KMsQf/5noaPrxgoTH9py4JgCwK6ab9M8BtAsAZ4xs6RUd6XEMeGsv4\n' +
-    //         'rLKKZhR0vMNnec/wHb3tNEFMihKsGkgCrycl4sJQIJsNX30bungrrC2XZUEAqN9g\n' +
-    //         '1IbDKAiq6l+0YQVC+742FZ6t7IgjrgV/lj7g0BMCgYEAkSeZiT/e0vvAFeR1lecY\n' +
-    //         'wgofbs9sWOnOCYTLr2MiHskunt39QTCs3PwVf9QV/63yuF0CnaMAUp8qDVO6Zch2\n' +
-    //         'LUM12e/eEpqWNHxZUhOA5wFn0yTaKb8nNNqaHxD6dXdR1U21cs3CDAEEsV16yx4k\n' +
-    //         '30TgKHZfC5+Q9XRQOAOUL0sCgYBcq/u78cphuwYvkhxU/4c0QW0eafu2K79ErXxO\n' +
-    //         'pMX0X8EBbDDBCEFbukSBtFyUnGtkWAyGXE5x3YiicMSuQSCkm6tVP4vq6lUFn0Hp\n' +
-    //         'o8s2ZdsEQDJ+adtDvRDqMEguZpZyPbiTAI2YM83asEQdy+7rn3czkeedNuwc9vTC\n' +
-    //         'bQYdkQKBgAqApiDmh84iMQUv5DQ2ks4Ddv/jpuYp/wELTN59n+IvP7BfdkOVBcYR\n' +
-    //         'Z1MZNo9fAIdF700ijKQKKgR1r5iOHiBo4A4DybxN3FHyS348BDbuh/dg2Z6307iS\n' +
-    //         'cNCq6ajhNeTtMy2E14DEdinp/7l2o87OpAR2cGRFBEi+f2RRQ2p0\n' +
-    //         '-----END RSA PRIVATE KEY-----'
-    //     jsb.setPrivateKey(privateString)
-    //     // 解密内容
-    //     let encrypted = jsb.decrypt(word)
-    //     return encrypted
-    // }
-
-    static getLocalTime(nS) {
-        return new Date(parseInt(nS) * 1000).toLocaleString().replace(/:\d{1,2}$/, ' ');
-    }
 }

mk_framework/assets/script/mk/utils/EncryptUtil.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.0.8",
+  "uuid": "4dd7cfb1-e0c4-4c52-90bd-939c7384452a",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

mk_framework/assets/script/mk/utils/TimeUtil.ts

@@ -13,7 +13,7 @@ export default class TimeUtil {
     private offTime: number = 0;
     /**
      * 设置服务器时间
-     * @param time 服务器时间戳（秒）
+     * @param time  服务器时间戳（秒）
      */
     public setServerTime(time: number) {
         this.offTime = time - Math.ceil(new Date().getTime() / 1000);
@@ -21,7 +21,7 @@ export default class TimeUtil {
 
     /**
      * 获取当前服务器时间，如果没有设置过服务器时间，默认为本地时间
-     * @returns 当前服务器时间戳（秒）
+     * @returns     当前服务器时间戳（秒）
      */
     public getServerTime(): number {
         return Math.ceil(new Date().getTime() / 1000 + this.offTime);
@@ -29,9 +29,9 @@ export default class TimeUtil {
 
     /**
      * 倒计时转换为时间格式(h:m:s)，没有单位
-     * @param t 时间（秒）
-     * @param f 格式，默认"h:m:s"，可以过滤，如 "m:s"
-     * @returns 规定格式的字符串 如"04:22:06"
+     * @param   t  时间（秒）
+     * @param   f  格式，默认"h:m:s"，可以过滤，如 "m:s"
+     * @returns    规定格式的字符串 如"04:22:06"
      */
     public format(t: number, f: string = "h:m:s"): string {
         let d: number = Math.floor(t / 24 / 3600);
@@ -80,9 +80,9 @@ export default class TimeUtil {
 
     /**
      * 倒计时转换为时间格式，带中文单位 ，可过滤
-     * @param t 时间（秒）
-     * @param f 格式，默认"天时分秒"，可以过滤，如 "分秒"
-     * @returns 规定格式的字符串 如“2天13时11分05秒”
+     * @param   t     时间（秒）
+     * @param   f     格式，默认"天时分秒"，可以过滤，如 "分秒"
+     * @returns       规定格式的字符串 如“2天13时11分05秒”
      */
     public formatWithUnit(t: number, f: string = "天时分秒"): string {
         let d: number = Math.floor(t / 24 / 3600);
@@ -129,8 +129,8 @@ export default class TimeUtil {
 
     /**
      * 获取一年中的第n天
-     * @param t
-     * @returns 一年中的第n天
+     * @param   t   时间戳（毫秒）
+     * @returns     一年中的第n天
      */
     public getDayInYear(t: number): number {
         var time: Date = new Date(t);
@@ -156,8 +156,8 @@ export default class TimeUtil {
 
     /**
      * 返回时间点在当天的秒数
-     * @param date 
-     * @returns 从零点开始的秒数
+     * @param   date    时间
+     * @returns         从零点开始的秒数
      */
     public getSecondsInDay(date: Date) {
         return date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds();
@@ -165,8 +165,8 @@ export default class TimeUtil {
 
     /**
      * 获取当前日期
-     * @param replace 间隔符，默认'-'，则返回2020-10-10
-     * @returns 当前时间字符串
+     * @param   replace     间隔符，默认'-'，则返回2020-10-10
+     * @returns             当前时间字符串
      */
     public getNowDayString(replace: string = '-'): string {
         let date = new Date();

mk_framework/assets/script/mk/module.meta → mk_framework/assets/script/mk/utils/encrypt.meta

@@ -1,6 +1,6 @@
 {
   "ver": "1.1.2",
-  "uuid": "ab0f2986-3ca8-4997-b562-d19946ea75de",
+  "uuid": "73f6c6f3-f1fe-4575-ae77-46117c8488bd",
   "isBundle": false,
   "bundleName": "",
   "priority": 1,