@chiyou/minigame-framework 1.0.0 → 1.0.2

package/assets/Scripts/Framework/Utils/CSVUtils.ts

@@ -0,0 +1,396 @@
+var CELL_DELIMITERS = [",", ";", "\t", "|", "^"];
+var LINE_DELIMITERS = ["\r\n", "\r", "\n"];
+
+var getter = function (index) {
+    return ("d[" + index + "]");
+};
+
+var getterCast = function(value, index, cast, d) {
+
+    if (cast instanceof Array) {
+        if (cast[index] === "number") {
+            return Number(d[index]);
+        } else if (cast[index] === "boolean") {
+            return d[index] === "true" ||  d[index] === "t" || d[index] === "1";
+        } else {
+            return d[index];
+        }
+    } else {
+        if (!isNaN(Number(value))) {
+            return Number(d[index]);
+        } else if (value == "false" || value == "true" || value == "t" || value == "f") {
+            return d[index] === "true" ||  d[index] === "t" || d[index] === "1";
+        } else {
+            return d[index];
+        }
+    }
+};
+
+var CSV = {
+    STANDARD_DECODE_OPTS: {
+        skip: 0,
+        limit: false,
+        header: false,
+        cast: false,
+        comment: ""
+    },
+
+    STANDARD_ENCODE_OPTS: {
+        delimiter: CELL_DELIMITERS[0],
+        newline: LINE_DELIMITERS[0],
+        skip: 0,
+        limit: false,
+        header: false
+    },
+
+    quoteMark: '"',
+    doubleQuoteMark: '""',
+    quoteRegex: /"/g,
+
+    assign: function () {
+        var args = Array.prototype.slice.call(arguments);
+        var base = args[0];
+        var rest = args.slice(1);
+        for (var i = 0, len = rest.length; i < len; i++) {
+            for (var attr in rest[i]) {
+                base[attr] = rest[i][attr];
+            }
+        }
+
+        return base;
+    },
+
+    map: function (collection, fn) {
+        var results = [];
+        for (var i = 0, len = collection.length; i < len; i++) {
+            results[i] = fn(collection[i], i);
+        }
+
+        return results;
+    },
+
+    getType: function (obj) {
+        return Object.prototype.toString.call(obj).slice(8, -1);
+    },
+
+    getLimit: function (limit, len) {
+        return limit === false ? len : limit;
+    },
+
+    buildObjectConstructor: function(fields, sample, cast) {
+        return function(d) {
+            var object = new Object();
+            var setter = function(attr, value) {
+                return object[attr] = value;
+            };
+            if (cast) {
+                fields.forEach(function(attr, idx) {
+                    setter(attr, getterCast(sample[idx], idx, cast, d));
+                });
+            } else {
+                fields.forEach(function(attr, idx) {
+                    setter(attr, getterCast(sample[idx], idx, null, d));
+                });
+            }
+            // body.push("return object;");
+            // body.join(";\n");
+            return object;
+        };
+    },
+
+    buildArrayConstructor: function(fields, sample, cast) {
+        return function(d) {
+            var row = new Array(sample.length);
+            var setter = function(idx, value) {
+                return row[idx] = value;
+            };
+            if (cast) {
+                fields.forEach(function(attr, idx) {
+                    setter(attr, getterCast(sample[idx], idx, cast, d));
+                });
+            } else {
+                fields.forEach(function(attr, idx) {
+                    setter(attr, getterCast(sample[idx], idx, null, d));
+                });
+            }
+            return row;
+        };
+    },
+
+    frequency: function (coll, needle, limit) {
+        if (limit === void 0) limit = false;
+
+        var count = 0;
+        var lastIndex = 0;
+        var maxIndex = this.getLimit(limit, coll.length);
+
+        while (lastIndex < maxIndex) {
+            lastIndex = coll.indexOf(needle, lastIndex);
+            if (lastIndex === -1) break;
+            lastIndex += 1;
+            count++;
+        }
+
+        return count;
+    },
+
+    mostFrequent: function (coll, needles, limit) {
+        var max = 0;
+        var detected;
+
+        for (var cur = needles.length - 1; cur >= 0; cur--) {
+            if (this.frequency(coll, needles[cur], limit) > max) {
+                detected = needles[cur];
+            }
+        }
+
+        return detected || needles[0];
+    },
+
+    unsafeParse: function (text, opts, fn) {
+        var lines = text.split(opts.newline);
+
+        if (opts.skip > 0) {
+            lines.splice(opts.skip);
+        }
+
+        var fields;
+        var constructor;
+
+        function cells(lines) {
+            var line = lines.shift();
+            if (line.indexOf('"') >= 0) {
+
+                var lastIndex = 0;
+                var findIndex = 0;
+                var count = 0;
+                while (lines.length > 0) {
+                    lastIndex = line.indexOf('"', findIndex);
+                    if (lastIndex === -1 && count % 2 === 0) break;
+
+                    if (lastIndex !== -1) {
+                        findIndex = lastIndex + 1;
+                        count++;
+                    } else {
+                        line = line + opts.newline + lines.shift();
+                    }
+                }
+
+                var list = [];
+                var item;
+
+                var quoteCount = 0;
+
+                var start = 0;
+                var end = 0;
+                var length = line.length;
+                for (var key in line) {
+                    if (!line.hasOwnProperty(key)) {
+                        continue;
+                    }
+
+                    let numKey = parseInt(key);
+                    var value = line[key];
+
+                    if (numKey === 0 && value === '"') {
+                        quoteCount++;
+                        start = 1;
+                    }
+
+                    if (value === '"') {
+                        quoteCount++;
+
+                        if (line[numKey - 1] === opts.delimiter && start === numKey) {
+                            start++;
+                        }
+                    }
+
+                    if (value === '"' && quoteCount % 2 === 0) {
+
+                        if (line[numKey + 1] === opts.delimiter || numKey + 1 === length) {
+                            end = numKey;
+                            item = line.substring(start, end);
+                            list.push(item);
+                            start = end + 2;
+                            end = start;
+                        }
+
+                    }
+
+                    if (value === opts.delimiter && quoteCount % 2 === 0) {
+                        end = numKey;
+                        if (end > start) {
+                            item = line.substring(start, end);
+                            list.push(item);
+                            start = end + 1;
+                            end = start;
+                        } else if (end === start) {
+                            list.push("");
+                            start = end + 1;
+                            end = start;
+                        }
+                    }
+
+                }
+
+                end = length;
+
+                if (end >= start) {
+                    item = line.substring(start, end);
+                    list.push(item);
+                }
+
+                return list;
+            } else {
+                return line.split(opts.delimiter);
+            }
+        }
+
+        if (opts.header) {
+            if (opts.header === true) {
+                opts.comment = cells(lines); // 第一行是注释
+                opts.cast = cells(lines); // 第二行是数据类型
+                fields = cells(lines); // 第三行是字段
+            } else if (this.getType(opts.header) === "Array") {
+                fields = opts.header;
+            }
+
+            constructor = this.buildObjectConstructor(fields, lines[0].split(opts.delimiter), opts.cast);
+        } else {
+            constructor = this.buildArrayConstructor(fields, lines[0].split(opts.delimiter), opts.cast);
+        }
+
+        while (lines.length > 0) {
+            var row = cells(lines);
+            if (row.length > 1) {
+                fn(constructor(row), fields[0]);
+            }
+        }
+
+        return true;
+    },
+
+    safeParse: function (text, opts, fn) {
+        var delimiter = opts.delimiter;
+        var newline = opts.newline;
+
+        var lines = text.split(newline);
+        if (opts.skip > 0) {
+            lines.splice(opts.skip);
+        }
+
+        return true;
+    },
+
+    encodeCells: function (line, delimiter, newline) {
+        var row = line.slice(0);
+        for (var i = 0, len = row.length; i < len; i++) {
+            if (row[i].indexOf(this.quoteMark) !== -1) {
+                row[i] = row[i].replace(this.quoteRegex, this.doubleQuoteMark);
+            }
+
+            if (row[i].indexOf(delimiter) !== -1 || row[i].indexOf(newline) !== -1) {
+                row[i] = this.quoteMark + row[i] + this.quoteMark;
+            }
+        }
+
+        return row.join(delimiter);
+    },
+
+    encodeArrays: function(coll, opts, fn) {
+        var delimiter = opts.delimiter;
+        var newline = opts.newline;
+
+        if (opts.header && this.getType(opts.header) === "Array") {
+            fn(this.encodeCells(opts.header, delimiter, newline));
+        }
+
+        for (var cur = 0, lim = this.getLimit(opts.limit, coll.length); cur < lim; cur++) {
+            fn(this.encodeCells(coll[cur], delimiter, newline));
+        }
+
+        return true;
+    },
+
+    encodeObjects: function (coll, opts, fn) {
+        var delimiter = opts.delimiter;
+        var newline = opts.newline;
+        var header;
+        var row;
+
+        header = [];
+        row = [];
+        for (var key in coll[0]) {
+            header.push(key);
+            row.push(coll[0][key]);
+        }
+
+        if (opts.header === true) {
+            fn(this.encodeCells(header, delimiter, newline));
+        } else if (this.getType(opts.header) === "Array") {
+            fn(this.encodeCells(opts.header, delimiter, newline));
+        }
+
+        fn(this.encodeCells(row, delimiter));
+
+        for (var cur = 1, lim = this.getLimit(opts.limit, coll.length); cur < lim; cur++) {
+            row = [];
+            for (var key$1 = 0, len = header.length; key$1 < len; key$1++) {
+                row.push(coll[cur][header[key$1]]);
+            }
+
+            fn(this.encodeCells(row, delimiter, newline));
+        }
+
+        return true;
+    },
+
+    parse: function (text, opts, fn) {
+        var rows;
+
+        if (this.getType(opts) === "Function") {
+            fn = opts;
+            opts = {};
+        } else if (this.getType(fn) !== "Function") {
+            rows = [];
+            fn = rows.push.bind(rows);
+        } else {
+            rows = [];
+        }
+
+        opts = this.assign({}, this.STANDARD_DECODE_OPTS, opts);
+        this.opts = opts;
+
+        if (!opts.delimiter || !opts.newline) {
+            var limit = Math.min(48, Math.floor(text.length / 20), text.length);
+            opts.delimiter = opts.delimiter || this.mostFrequent(text, CELL_DELIMITERS, limit);
+            opts.newline = opts.newline || this.mostFrequent(text, LINE_DELIMITERS, limit);
+        }
+
+        return this.unsafeParse(text, opts, fn) &&
+            (rows.length > 0 ? rows : true);
+    },
+
+    encode: function (coll, opts, fn) {
+        var lines;
+
+        if (this.getType(opts) === "Function") {
+            fn = opts;
+            opts = {};
+        } else if (this.getType(fn) !== "Function") {
+            lines = [];
+            fn = lines.push.bind(lines);
+        }
+
+        opts = this.assign({}, this.STANDARD_ENCODE_OPTS, opts);
+
+        if (opts.skip > 0) {
+            coll = coll.slice(opts.skip);
+        }
+
+        return (this.getType(coll[0]) === "Array" ? this.encodeArrays : this.encodeObjects)(coll, opts, fn) &&
+            (lines.length > 0 ? lines.join(opts.newline) : true);
+    }
+};
+
+export default CSV;

package/assets/Scripts/Framework/Utils/CSVUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "c3940c0f-5ad5-474c-be18-6804fbe5491f",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils/LogUtils.ts

@@ -0,0 +1,32 @@
+import { sys } from "cc";
+
+export class LogUtils {
+    public static Instance: LogUtils = new LogUtils();
+    static TAG: string = "LogUtils";
+
+    private isDebug: boolean = false;
+
+    public init(isDebug: boolean): void {
+        this.isDebug = isDebug;
+
+        LogUtils.Instance.log(LogUtils.TAG, "init() finished.");
+    }
+
+    public log(tag: string, ...data: any[]): void {
+        if (this.isDebug) {
+            if (tag && tag.length > 0) {
+                if (sys.platform === sys.Platform.HUAWEI_QUICK_GAME) {
+                    console.log(new Date().getTime().toString() + " [" + tag + "]: ", JSON.stringify(data));
+                } else {
+                    console.log(new Date().getTime().toString() + " [" + tag + "]: ", ...data);
+                }
+            } else {
+                if (sys.platform === sys.Platform.HUAWEI_QUICK_GAME) {
+                    console.log(JSON.stringify(data));
+                } else {
+                    console.log(...data);
+                }
+            }
+        }
+    }
+}

package/assets/Scripts/Framework/Utils/LogUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "cab449cb-80e7-4731-a1ff-51fb92588e37",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils/NumberUtils.ts

@@ -0,0 +1,51 @@
+export class NumberUtils {
+
+    /**
+     * 给数字添加前导0
+     * @param num 数字
+     * @param length 总长度
+     * @returns 前导0后的字符串
+     */
+    public static prefixInteger(num: number, length: number): string {
+        let result: string = "";
+
+        for (let i = length - 1; i >= 0; i--) {
+            const remainNum: number = num % Math.pow(10, i + 1);
+            result += Math.floor(remainNum / Math.pow(10, i));
+        }
+
+        return result;
+    }
+
+    /**
+     * 比较版本号
+     * @param v1 版本号1
+     * @param v2 版本号2
+     * @returns 1: v1大于v2, -1: v1小于v2, 0: v1等于v2
+     */
+    public static compareVersion(v1: string, v2: string): number {
+        let v1Array: string[] = v1.split('.');
+        let v2Array: string[] = v2.split('.');
+        const len = Math.max(v1.length, v2.length);
+      
+        while (v1Array.length < len) {
+            v1Array.push('0');
+        }
+        while (v2Array.length < len) {
+            v2Array.push('0');
+        }
+      
+        for (let i = 0; i < len; i++) {
+            const num1 = parseInt(v1Array[i]);
+            const num2 = parseInt(v2Array[i]);
+        
+            if (num1 > num2) {
+                return 1;
+            } else if (num1 < num2) {
+                return -1;
+            }
+        }
+      
+        return 0;
+    }
+}

package/assets/Scripts/Framework/Utils/NumberUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "997c8652-636c-4ea3-ac1d-308c4fcc0893",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils/TaskUtils.ts

@@ -0,0 +1,27 @@
+export type AsyncTask = Promise<any>;
+
+export class TaskUtils {
+
+    /**
+     * 并行执行异步任务数组，确保总执行时间不小于指定的最小持续时间
+     * @param minDuration 最小持续时间（毫秒）
+     * @param tasks 异步任务数组
+     * @returns 所有任务执行完成的 Promise
+     */
+    public static executeAsyncTasksWithMinDuration(minDuration: number, tasks: AsyncTask[]): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+
+            Promise.all(tasks)
+                .then(() => {
+                    const elapsed = Date.now() - startTime;
+                    if (elapsed < minDuration) {
+                        setTimeout(resolve, minDuration - elapsed);
+                    } else {
+                        resolve();
+                    }
+                })
+                .catch(reject);
+        });
+    }
+}

package/assets/Scripts/Framework/Utils/TaskUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "9cfc9976-e30c-4fa6-8d35-87e76b6d092a",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils/TimeUtils.ts

@@ -0,0 +1,38 @@
+import { NumberUtils } from "./NumberUtils";
+
+export class TimeUtils {
+
+    /**
+     * 格式化时间为分秒格式
+     * @param seconds 时间（秒）
+     * @returns 格式化后的时间字符串（分:秒）
+     */
+    public static formatTime(seconds: number): string {
+        let minute: number = Math.floor(seconds / 60);
+        let second: number = seconds % 60;
+
+        let result: string = NumberUtils.prefixInteger(minute, 2) + ":" + NumberUtils.prefixInteger(second, 2);
+        return result;
+    }
+
+    /**
+     * 获取当前时间戳（秒）
+     * @returns 当前时间戳（秒）
+     */
+    public static nowTimestampInSecond(): number {
+        return Math.floor(Date.now() / 1000);
+    }
+
+    /**
+     * 等待指定时间
+     * @param time 等待时间（秒）
+     * @returns 等待完成的 Promise
+     */
+    public static wait(time: number): Promise<void> {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, time * 1000);
+        });
+    }
+}

package/assets/Scripts/Framework/Utils/TimeUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "b21ea81b-b368-4233-a401-d9ab88867ab7",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils/WXBizDataCryptUtils.ts

@@ -0,0 +1,54 @@
+import CryptoJS from 'crypto-js';
+
+export class WXDecryptResult {
+    success: boolean;
+    jsonData: any;
+
+    constructor() {
+        this.success = false;
+        this.jsonData = null;
+    }
+}
+
+class WXBizDataCryptUtils {
+    appId: string;
+    sessionKey: string;
+
+    constructor(appId: string, sessionKey: string) {
+        this.appId = appId;
+        this.sessionKey = sessionKey;
+    }
+
+    public decryptData(encryptedData: string, iv: string): WXDecryptResult {
+        let result: WXDecryptResult = new WXDecryptResult();
+        // 将Base64字符串转换为WordArray（crypto-js的内部格式）
+        const sessionKeyBase64 = CryptoJS.enc.Base64.parse(this.sessionKey);
+        const encryptedDataBase64 = CryptoJS.enc.Base64.parse(encryptedData);
+        const ivBase64 = CryptoJS.enc.Base64.parse(iv);
+
+        // 解密
+        const decrypted = CryptoJS.AES.decrypt(
+        { ciphertext: encryptedDataBase64 } as any, // 类型适配
+        sessionKeyBase64,
+        { iv: ivBase64, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
+        );
+
+        // 转换为UTF8字符串
+        const resultStr = decrypted.toString(CryptoJS.enc.Utf8);
+        if (!resultStr) {
+            return result;
+        }
+
+        const jsonData = JSON.parse(resultStr);
+        // 验证水印
+        if (jsonData.watermark && jsonData.watermark.appid !== this.appId) {
+            return result;
+        }
+
+        result.success = true;
+        result.jsonData = jsonData;
+        return result;
+    }
+}
+
+export default WXBizDataCryptUtils;

package/assets/Scripts/Framework/Utils/WXBizDataCryptUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "e6024e35-4ba0-4b4d-aa6f-5a56b011961a",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "bf481377-3692-42eb-873f-1402d542c5d8",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "735a8161-dee6-49c7-8037-a2235c697b41",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}