@chiyou/minigame-framework 1.0.0

package/dist/Framework/Utils/CSVUtils.d.ts

@@ -0,0 +1,35 @@
+declare var CSV: {
+    STANDARD_DECODE_OPTS: {
+        skip: number;
+        limit: boolean;
+        header: boolean;
+        cast: boolean;
+        comment: string;
+    };
+    STANDARD_ENCODE_OPTS: {
+        delimiter: string;
+        newline: string;
+        skip: number;
+        limit: boolean;
+        header: boolean;
+    };
+    quoteMark: string;
+    doubleQuoteMark: string;
+    quoteRegex: RegExp;
+    assign: () => any;
+    map: (collection: any, fn: any) => any[];
+    getType: (obj: any) => any;
+    getLimit: (limit: any, len: any) => any;
+    buildObjectConstructor: (fields: any, sample: any, cast: any) => (d: any) => Object;
+    buildArrayConstructor: (fields: any, sample: any, cast: any) => (d: any) => any[];
+    frequency: (coll: any, needle: any, limit: any) => number;
+    mostFrequent: (coll: any, needles: any, limit: any) => any;
+    unsafeParse: (text: any, opts: any, fn: any) => boolean;
+    safeParse: (text: any, opts: any, fn: any) => boolean;
+    encodeCells: (line: any, delimiter: any, newline: any) => any;
+    encodeArrays: (coll: any, opts: any, fn: any) => boolean;
+    encodeObjects: (coll: any, opts: any, fn: any) => boolean;
+    parse: (text: any, opts: any, fn: any) => any;
+    encode: (coll: any, opts: any, fn: any) => any;
+};
+export default CSV;

package/dist/Framework/Utils/CSVUtils.js

@@ -0,0 +1,341 @@
+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/dist/Framework/Utils/LogUtils.d.ts

@@ -0,0 +1,7 @@
+export declare class LogUtils {
+    static Instance: LogUtils;
+    static TAG: string;
+    private isDebug;
+    init(isDebug: boolean): void;
+    log(tag: string, ...data: any[]): void;
+}

package/dist/Framework/Utils/LogUtils.js

@@ -0,0 +1,32 @@
+import { sys } from "cc";
+export class LogUtils {
+    constructor() {
+        this.isDebug = false;
+    }
+    init(isDebug) {
+        this.isDebug = isDebug;
+        LogUtils.Instance.log(LogUtils.TAG, "init() finished.");
+    }
+    log(tag, ...data) {
+        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);
+                }
+            }
+        }
+    }
+}
+LogUtils.Instance = new LogUtils();
+LogUtils.TAG = "LogUtils";

package/dist/Framework/Utils/NumberUtils.d.ts

@@ -0,0 +1,16 @@
+export declare class NumberUtils {
+    /**
+     * 给数字添加前导0
+     * @param num 数字
+     * @param length 总长度
+     * @returns 前导0后的字符串
+     */
+    static prefixInteger(num: number, length: number): string;
+    /**
+     * 比较版本号
+     * @param v1 版本号1
+     * @param v2 版本号2
+     * @returns 1: v1大于v2, -1: v1小于v2, 0: v1等于v2
+     */
+    static compareVersion(v1: string, v2: string): number;
+}

package/dist/Framework/Utils/NumberUtils.js

@@ -0,0 +1,44 @@
+export class NumberUtils {
+    /**
+     * 给数字添加前导0
+     * @param num 数字
+     * @param length 总长度
+     * @returns 前导0后的字符串
+     */
+    static prefixInteger(num, length) {
+        let result = "";
+        for (let i = length - 1; i >= 0; i--) {
+            const remainNum = 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
+     */
+    static compareVersion(v1, v2) {
+        let v1Array = v1.split('.');
+        let v2Array = 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/dist/Framework/Utils/TaskUtils.d.ts

@@ -0,0 +1,10 @@
+export type AsyncTask = Promise<any>;
+export declare class TaskUtils {
+    /**
+     * 并行执行异步任务数组，确保总执行时间不小于指定的最小持续时间
+     * @param minDuration 最小持续时间（毫秒）
+     * @param tasks 异步任务数组
+     * @returns 所有任务执行完成的 Promise
+     */
+    static executeAsyncTasksWithMinDuration(minDuration: number, tasks: AsyncTask[]): Promise<void>;
+}

package/dist/Framework/Utils/TaskUtils.js

@@ -0,0 +1,24 @@
+export class TaskUtils {
+    /**
+     * 并行执行异步任务数组，确保总执行时间不小于指定的最小持续时间
+     * @param minDuration 最小持续时间（毫秒）
+     * @param tasks 异步任务数组
+     * @returns 所有任务执行完成的 Promise
+     */
+    static executeAsyncTasksWithMinDuration(minDuration, tasks) {
+        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/dist/Framework/Utils/TimeUtils.d.ts

@@ -0,0 +1,19 @@
+export declare class TimeUtils {
+    /**
+     * 格式化时间为分秒格式
+     * @param seconds 时间（秒）
+     * @returns 格式化后的时间字符串（分:秒）
+     */
+    static formatTime(seconds: number): string;
+    /**
+     * 获取当前时间戳（秒）
+     * @returns 当前时间戳（秒）
+     */
+    static nowTimestampInSecond(): number;
+    /**
+     * 等待指定时间
+     * @param time 等待时间（秒）
+     * @returns 等待完成的 Promise
+     */
+    static wait(time: number): Promise<void>;
+}

package/dist/Framework/Utils/TimeUtils.js

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

package/dist/Framework/Utils/WXBizDataCryptUtils.d.ts

@@ -0,0 +1,12 @@
+export declare class WXDecryptResult {
+    success: boolean;
+    jsonData: any;
+    constructor();
+}
+declare class WXBizDataCryptUtils {
+    appId: string;
+    sessionKey: string;
+    constructor(appId: string, sessionKey: string);
+    decryptData(encryptedData: string, iv: string): WXDecryptResult;
+}
+export default WXBizDataCryptUtils;

package/dist/Framework/Utils/WXBizDataCryptUtils.js

@@ -0,0 +1,37 @@
+import CryptoJS from 'crypto-js';
+export class WXDecryptResult {
+    constructor() {
+        this.success = false;
+        this.jsonData = null;
+    }
+}
+class WXBizDataCryptUtils {
+    constructor(appId, sessionKey) {
+        this.appId = appId;
+        this.sessionKey = sessionKey;
+    }
+    decryptData(encryptedData, iv) {
+        let result = 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 }, // 类型适配
+        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/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * MiniGameFramework - 基于 Cocos Creator 3.x 的小游戏开发框架
+ *
+ * @module MiniGameFramework
+ */
+export { ResMgr } from './Framework/Manager/ResMgr';
+export { UIMgr, UICtrl } from './Framework/Manager/UIMgr';
+export { EventMgr } from './Framework/Manager/EventMgr';
+export { AudioMgr } from './Framework/Manager/AudioMgr';
+export { UserMgr } from './Framework/Manager/UserMgr';
+export { SocialMgr } from './Framework/Manager/SocialMgr';
+export { AdMgr } from './Framework/Manager/AdMgr';
+export { SystemMgr } from './Framework/Manager/SystemMgr';
+export { TimerMgr } from './Framework/Manager/TimerMgr';
+export { PrivacyMgr } from './Framework/Manager/PrivacyMgr';
+export { LifeCycleMgr } from './Framework/Manager/LifeCycleMgr';
+export { BaseMgr } from './Framework/Manager/BaseMgr';
+export { NodePoolMgr } from './Framework/Manager/NodePoolMgr';
+export { LogUtils } from './Framework/Utils/LogUtils';
+export { TaskUtils } from './Framework/Utils/TaskUtils';
+export { BezierUtils } from './Framework/Utils/BezierUtils';
+export { NumberUtils } from './Framework/Utils/NumberUtils';
+export { TimeUtils } from './Framework/Utils/TimeUtils';
+export * from './Framework/Definition/SystemDefinition';
+export * from './Framework/Definition/UserDefinition';
+export * from './Framework/Definition/AdDefinition';
+export * from './Framework/Definition/PrivacyDefinition';
+export * from './Framework/Definition/SocialDefinition';
+export * from './Framework/Definition/UIDefinition';
+export * from './Framework/Definition/FrameworkBase';