@xiacg/exia-assets 1.0.0

package/dist/exia-assets.mjs

@@ -0,0 +1,742 @@
+import { Asset, resources, assetManager } from 'cc';
+
+/** 资源加载的状态类型 */
+var StateType;
+(function (StateType) {
+    StateType[StateType["Error"] = 0] = "Error";
+    StateType[StateType["Wait"] = 1] = "Wait";
+    StateType[StateType["Loading"] = 2] = "Loading";
+    StateType[StateType["Finish"] = 3] = "Finish";
+})(StateType || (StateType = {}));
+var ErrorCode;
+(function (ErrorCode) {
+    /** 文件加载失败 */
+    ErrorCode[ErrorCode["FileLoadFailed"] = 1] = "FileLoadFailed";
+    /** 资源包加载失败 */
+    ErrorCode[ErrorCode["BundleLoadFailed"] = 2] = "BundleLoadFailed";
+})(ErrorCode || (ErrorCode = {}));
+
+class AssetInfo {
+    /**
+     * @param info IAssetConfig 资源配置
+     * @param count number 资源数量
+     *
+     * @internal
+     */
+    constructor(info, bundle, status = StateType.Wait) {
+        /** @internal */
+        this._type = Asset;
+        /** @internal */
+        this._path = "";
+        /** @internal */
+        this._isFile = false;
+        /** @internal */
+        this._bundle = "resources";
+        /** @internal */
+        this._assetBundle = resources;
+        /** @internal */
+        this._status = StateType.Wait;
+        this._type = info.type || Asset;
+        this._path = info.path;
+        this._isFile = info.isFile || false;
+        this._bundle = info.bundle || "resources";
+        this._assetBundle = bundle;
+        this._status = status;
+    }
+    /** 固定的属性 */
+    get type() {
+        return this._type;
+    }
+    get path() {
+        return this._path;
+    }
+    get isFile() {
+        return this._isFile;
+    }
+    get bundle() {
+        return this._bundle;
+    }
+    get assetBundle() {
+        return this._assetBundle;
+    }
+    /** 可变的属性 */
+    get status() {
+        return this._status;
+    }
+    set status(status) {
+        this._status = status;
+    }
+}
+
+class AssetLoaderAgent {
+    constructor() {
+        /** @internal */
+        this._maxParallel = 10;
+        /** @internal */
+        this._maxRetry = 0;
+        /**
+         * 资源加载项
+         * @internal
+         */
+        this._assetInfos = [];
+        /**
+         * 加载完成数量
+         * @internal
+         */
+        this._completeCounts = new Map();
+        /** 是否加载完成 @internal */
+        this._isComplete = false;
+        /********************** 回调相关内容 end **********************/
+    }
+    /**
+     * 设置最大并行数量
+     * @param {number} parallel 最大并行数量
+     */
+    set parallel(parallel) {
+        this._maxParallel = Math.max(1, parallel);
+    }
+    /**
+     * 设置失败重试次数
+     * @param {number} retry 失败重试次数 默认: 0
+     */
+    set retry(retry) {
+        this._maxRetry = retry;
+    }
+    /** @internal */
+    initialize() {
+        this._isComplete = false;
+        this._assetInfos.length = 0;
+        this._completeCounts.clear();
+    }
+    /**
+     * 设置资源总数量
+     * @param bundle bundle名
+     * @param path 资源路径
+     * @param total 总数量
+     * @internal
+     */
+    setTotalCount(bundle, path, total) {
+        let key = `${bundle}:${path}`;
+        this._completeCounts.set(key, { value: 0, total: total });
+    }
+    /**
+     * 添加加载完成数量
+     * @param bundle bundle名
+     * @param path 资源路径
+     * @param count 完成数量
+     * @internal
+     */
+    updateCompleteCount(bundle, path, count, total) {
+        let key = `${bundle}:${path}`;
+        if (this._completeCounts.has(key)) {
+            let info = this._completeCounts.get(key);
+            info.value = Math.min(count, total);
+            info.total = total;
+        }
+        else {
+            this._completeCounts.set(key, {
+                value: Math.min(count, total),
+                total: total,
+            });
+        }
+        this.progressUpdate();
+    }
+    /** @internal */
+    addAssetInfo(info) {
+        this._assetInfos.push(info);
+    }
+    /** 通过索引获取 */
+    getAssetInfo(index) {
+        return this._assetInfos[index];
+    }
+    /** @internal */
+    getAssetsCount() {
+        return this._assetInfos.length;
+    }
+    /**
+     * 找到第一个等待中资源的索引  如果不存在则返回 -1
+     * @internal
+     */
+    getFirstWaitIndex() {
+        return this._assetInfos.findIndex((item) => item.status == StateType.Wait);
+    }
+    /** @internal */
+    isAllFinished() {
+        return this._assetInfos.every((item) => item.status == StateType.Finish);
+    }
+    /**
+     * 重置失败资源状态为等待中
+     * @internal
+     */
+    resetErrorAssets() {
+        let count = 0;
+        for (const item of this._assetInfos) {
+            if (item.status == StateType.Error) {
+                item.status = StateType.Wait;
+                count++;
+            }
+        }
+        return count;
+    }
+    downloadFaildAnalysis() {
+        // 找到所有失败的资源 把路径拼成字符串
+        let paths = [];
+        for (const item of this._assetInfos) {
+            if (item.status == StateType.Error) {
+                paths.push(`bundle:${item.bundle} path:${item.path}`);
+            }
+        }
+        let msg = `加载失败资源:\n${paths.join("\n")}`;
+        this.failCallback(ErrorCode.FileLoadFailed, msg);
+    }
+    /**
+     * @param res 设置回调函数
+     * @param {Function} res.complete 加载完成回调
+     * @param {Function} res.fail 加载失败回调
+     * @param {Function} res.progress 加载进度回调
+     */
+    setCallbacks(res) {
+        this._complete = res.complete || (() => { });
+        this._fail = res.fail || (() => { });
+        this._progress = res.progress || (() => { });
+    }
+    /** @internal */
+    progressUpdate() {
+        if (!this._progress) {
+            return;
+        }
+        let count = 0, totalCount = 0;
+        for (const { value, total } of this._completeCounts.values()) {
+            count += value;
+            totalCount += total;
+        }
+        this._progress(Math.max(Math.min(count / totalCount, 1), 0));
+    }
+    /** @internal */
+    completeAll() {
+        var _a;
+        if (this._isComplete) {
+            return;
+        }
+        this._isComplete = true;
+        (_a = this._complete) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    /** @internal */
+    failCallback(code, msg) {
+        var _a;
+        (_a = this._fail) === null || _a === void 0 ? void 0 : _a.call(this, code, msg);
+    }
+}
+
+class AssetUtils {
+    /** 获取资源数量 */
+    static getResourceCount(dir, type, bundle = resources) {
+        dir = assetManager.utils.normalize(dir);
+        if (dir[dir.length - 1] === "/") {
+            dir = dir.slice(0, -1);
+        }
+        let list = bundle.getDirWithPath(dir, type);
+        return list.length;
+    }
+    /** 获取资源名称 */
+    static getUUIDs(dir, type, bundle = resources) {
+        let uuids = [];
+        let path = assetManager.utils.normalize(dir);
+        if (path[path.length - 1] === "/") {
+            path = path.slice(0, -1);
+        }
+        let list = bundle.getDirWithPath(path, type);
+        for (const asset of list) {
+            uuids.push(asset.uuid);
+        }
+        return uuids;
+    }
+    /** 加载 bundle */
+    static loadBundle(bundlename) {
+        return new Promise((resolve, reject) => {
+            let bundle = assetManager.getBundle(bundlename);
+            if (bundle) {
+                resolve(bundle);
+            }
+            else {
+                assetManager.loadBundle(bundlename, (err, bundle) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(bundle);
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * 加载单个资源
+     * @param bundle 资源包名或资源包
+     * @param path 资源路径
+     * @param type 资源类型
+     * @param callbacks 回调函数
+     */
+    static loadFile(bundle, path, type, callbacks) {
+        if (typeof bundle === "string") {
+            AssetUtils.loadBundle(bundle)
+                .then((bundle) => {
+                // 加载单个资源
+                bundle.load(path, type, (error, asset) => {
+                    var _a, _b;
+                    if (error) {
+                        (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.fail) === null || _a === void 0 ? void 0 : _a.call(callbacks, ErrorCode.FileLoadFailed, `加载资源失败【bundle:${bundle} path:${path}】`);
+                    }
+                    else {
+                        (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.complete) === null || _b === void 0 ? void 0 : _b.call(callbacks, asset);
+                    }
+                });
+            })
+                .catch((err) => {
+                var _a;
+                (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.fail) === null || _a === void 0 ? void 0 : _a.call(callbacks, ErrorCode.BundleLoadFailed, `加载bundle[${bundle}]失败`);
+            });
+        }
+        else {
+            // 加载单个资源
+            bundle.load(path, type, (error, asset) => {
+                var _a, _b;
+                if (error) {
+                    (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.fail) === null || _a === void 0 ? void 0 : _a.call(callbacks, ErrorCode.FileLoadFailed, `加载资源失败【bundle:${bundle.name} path:${path}】`);
+                }
+                else {
+                    (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.complete) === null || _b === void 0 ? void 0 : _b.call(callbacks, asset);
+                }
+            });
+        }
+    }
+    /**
+     * 加载文件夹下的资源
+     * @param bundle 资源包名或资源包
+     * @param path 资源路径
+     * @param type 资源类型
+     * @param callbacks 回调函数
+     * @param callbacks.progress 进度回调 value: 已完成数量 total: 总数量
+     */
+    static loadDir(bundle, path, type, callbacks) {
+        if (typeof bundle === "string") {
+            AssetUtils.loadBundle(bundle)
+                .then((bundle) => {
+                bundle.loadDir(path, type, 
+                // 进度回调
+                (finished, total) => {
+                    var _a;
+                    (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.progress) === null || _a === void 0 ? void 0 : _a.call(callbacks, finished, total);
+                }, 
+                // 完成回调
+                (error, assets) => {
+                    var _a, _b;
+                    if (error) {
+                        (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.fail) === null || _a === void 0 ? void 0 : _a.call(callbacks, ErrorCode.FileLoadFailed, `加载文件夹失败【bundle:${bundle} path:${path}】`);
+                    }
+                    else {
+                        (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.complete) === null || _b === void 0 ? void 0 : _b.call(callbacks, assets);
+                    }
+                });
+            })
+                .catch((err) => {
+                var _a;
+                (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.fail) === null || _a === void 0 ? void 0 : _a.call(callbacks, ErrorCode.BundleLoadFailed, `加载bundle[${bundle}]失败`);
+            });
+        }
+        else {
+            bundle.loadDir(path, type, 
+            // 进度回调
+            (finished, total) => {
+                var _a;
+                (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.progress) === null || _a === void 0 ? void 0 : _a.call(callbacks, finished, total);
+            }, 
+            // 完成回调
+            (error, assets) => {
+                var _a, _b;
+                if (error) {
+                    (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.fail) === null || _a === void 0 ? void 0 : _a.call(callbacks, ErrorCode.FileLoadFailed, `加载文件夹失败【bundle:${bundle} path:${path}】`);
+                }
+                else {
+                    (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.complete) === null || _b === void 0 ? void 0 : _b.call(callbacks, assets);
+                }
+            });
+        }
+    }
+}
+
+class AssetPool {
+    /** 添加资源 */
+    static add(asset, bundle = resources, batchName = "") {
+        if (Array.isArray(asset)) {
+            for (const item of asset) {
+                this.add(item, bundle, batchName);
+            }
+        }
+        else {
+            let uuid = asset.uuid || asset._uuid;
+            if (this._uuidToName.has(uuid)) {
+                return;
+            }
+            // 增加引用计数
+            asset.addRef();
+            let info = bundle.getAssetInfo(uuid);
+            //TODO:: 这里使用了私有属性
+            /** @ts-ignore */
+            let key = this.getKey(info.path, bundle.name);
+            // log(`>>>uuid:${uuid}, path:${info.path}`);
+            this._uuidToName.set(uuid, key);
+            this._assets.set(key, asset);
+            // 添加到批次
+            this.addToBatch(batchName, key, asset);
+        }
+    }
+    static addToBatch(batchName, key, asset) {
+        if (!batchName) {
+            return;
+        }
+        if (!this._batchAssetNames.has(batchName)) {
+            this._batchAssetNames.set(batchName, new Set());
+        }
+        this._batchAssetNames.get(batchName).add(key);
+        this._assetToBatchName.set(asset, batchName);
+    }
+    static getAllAssetPaths() {
+        return Array.from(this._assets.keys());
+    }
+    /**
+     * 检查资源是否存在
+     * @param path 资源在bundle下的路径
+     * @param bundlename 资源bundle名 默认 resources
+     */
+    static has(path, bundlename = "resources") {
+        let key = this.getKey(path, bundlename);
+        return this._assets.has(key);
+    }
+    /**
+     * 获取资源
+     * @param path 资源在bundle下的路径
+     * @param bundlename 资源bundle名 默认 resources
+     */
+    static get(path, bundlename = "resources") {
+        let key = this.getKey(path, bundlename);
+        if (!this._assets.has(key)) {
+            console.warn(`获取资源失败: 资源 bundle:${bundlename}, path:${path} 未加载`);
+        }
+        return this._assets.get(key);
+    }
+    /**
+     * 按 uuid 判断资源是否存在
+     */
+    static hasUUID(uuid) {
+        if (!this._uuidToName.has(uuid)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 按 uuid 获取资源
+     */
+    static getByUUID(uuid) {
+        if (!this._uuidToName.has(uuid)) {
+            console.warn(`获取资源失败: 资源 uuid:${uuid} 未加载`);
+        }
+        let key = this._uuidToName.get(uuid);
+        return this._assets.get(key);
+    }
+    /**
+     * 按资源加载批次释放资源
+     * @param batchName 资源加载批次名 对应 AssetLoader 实例化时传入的 name
+     */
+    static releaseBatchAssets(batchName) {
+        if (!this._batchAssetNames.has(batchName)) {
+            return;
+        }
+        let names = this._batchAssetNames.get(batchName);
+        for (const name of names) {
+            this.release(name);
+        }
+        this._batchAssetNames.delete(batchName);
+    }
+    /**
+     * 按资源路径释放资源
+     * @param path 资源在bundle下的路径
+     * @param bundlename 资源bundle名 默认 resources
+     */
+    static releasePath(path, bundlename = "resources") {
+        let key = this.getKey(path, bundlename);
+        this.release(key);
+    }
+    /**
+     * 按 bundle、文件夹和资源类型释放资源
+     * @param dir 资源在bundle下的路径
+     * @param bundlename 资源bundle名 默认 resources
+     * @param asset 资源类型 不传表示所有类型的资源
+     */
+    static releaseDir(dir, bundlename = "resources", asset) {
+        return new Promise((resolve, reject) => {
+            if (bundlename == "resources") {
+                let uuids = AssetUtils.getUUIDs(dir, asset, resources);
+                for (const uuid of uuids) {
+                    this.releaseUUID(uuid);
+                }
+                resolve(true);
+            }
+            else {
+                AssetUtils.loadBundle(bundlename)
+                    .then((bundle) => {
+                    let uuids = AssetUtils.getUUIDs(dir, asset, bundle);
+                    for (const uuid of uuids) {
+                        this.releaseUUID(uuid);
+                    }
+                    resolve(true);
+                })
+                    .catch((err) => {
+                    reject(false);
+                });
+            }
+        });
+    }
+    /**
+     * 按 uuid 释放资源
+     */
+    static releaseUUID(uuid) {
+        if (this._uuidToName.has(uuid)) {
+            let key = this._uuidToName.get(uuid);
+            this.release(key);
+        }
+    }
+    /**
+     * 释放所有加载的资源
+     */
+    static releaseAll() {
+        this._assets.forEach((asset, key) => {
+            asset.decRef();
+        });
+        this._assets.clear();
+        this._uuidToName.clear();
+        this._batchAssetNames.clear();
+    }
+    /**
+     * 按key释放资源
+     * @internal
+     */
+    static release(key) {
+        if (this._assets.has(key)) {
+            let asset = this._assets.get(key);
+            if (this._assetToBatchName.has(asset)) {
+                let batchName = this._assetToBatchName.get(asset);
+                this._batchAssetNames.get(batchName).delete(key);
+                this._assetToBatchName.delete(asset);
+            }
+            this._uuidToName.delete(asset.uuid);
+            asset.decRef();
+            this._assets.delete(key);
+        }
+        else {
+            console.warn(`释放资源失败: 资源【${key}】未加载`);
+        }
+    }
+    /**
+     * 获取资源 key
+     * @internal
+     */
+    static getKey(path, bundlename = "resources") {
+        return `${bundlename}:${path}`;
+    }
+}
+/**
+ * 资源名对应的资源
+ * @internal
+ */
+AssetPool._assets = new Map();
+/**
+ * uuid 对应的资源名
+ * @internal
+ */
+AssetPool._uuidToName = new Map();
+/** @internal */
+AssetPool._batchAssetNames = new Map();
+/** @internal */
+AssetPool._assetToBatchName = new WeakMap();
+
+class AssetLoader extends AssetLoaderAgent {
+    constructor(batchName) {
+        super();
+        /** @internal */
+        this._name = "";
+        /**
+         * 当前并行加载数量
+         * @internal
+         */
+        this._parallel = 0;
+        /**
+         * 失败重试次数
+         * @internal
+         */
+        this._retry = 0;
+        /**
+         * 获取资源数量是否成功
+         * @internal
+         */
+        this._initSuccess = false;
+        /** @internal */
+        this._configs = [];
+        this._name = batchName || "";
+    }
+    /**
+     * 开始加载资源
+     * @param {IAssetConfig[]} res.configs 资源配置
+     */
+    start(assetConfigs) {
+        this._configs = assetConfigs;
+        this.onStart();
+    }
+    onStart() {
+        this.initialize();
+        this._initSuccess = false;
+        let initCount = this._configs.length;
+        for (const info of this._configs) {
+            let bundlename = info.bundle || "resources";
+            if (bundlename == "resources") {
+                let count = AssetUtils.getResourceCount(info.path, info.type, resources);
+                this.setTotalCount(bundlename, info.path, count);
+                this.addAssetInfo(new AssetInfo(info, resources));
+                initCount--;
+                initCount <= 0 && this.initSuccess();
+            }
+            else {
+                AssetUtils.loadBundle(bundlename)
+                    .then((bundle) => {
+                    let count = AssetUtils.getResourceCount(info.path, info.type, bundle);
+                    this.setTotalCount(bundlename, info.path, count);
+                    this.addAssetInfo(new AssetInfo(info, bundle));
+                    initCount--;
+                    initCount <= 0 && this.initSuccess();
+                })
+                    .catch((err) => {
+                    if (this._retry < this._maxRetry) {
+                        this._retry++;
+                        this.onStart();
+                    }
+                    else {
+                        this.failCallback(ErrorCode.BundleLoadFailed, `加载bundle【${bundlename}】失败`);
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * 初始化成功后，开始批量加载资源
+     * @internal
+     */
+    initSuccess() {
+        this._initSuccess = true;
+        this._parallel = 0;
+        let maxLoad = Math.min(this.getAssetsCount(), this._maxParallel);
+        for (let i = 0; i < maxLoad; i++) {
+            this.loadNext();
+        }
+    }
+    /**
+     * 加载下一个资源
+     * @internal
+     */
+    loadNext() {
+        // 存在等待中的资源，则加载等待中的资源
+        let index = this.getFirstWaitIndex();
+        if (index > -1) {
+            this.loadItem(index);
+            return;
+        }
+        // 所有资源全部完成了，则完成
+        if (this.isAllFinished()) {
+            this.completeAll();
+            return;
+        }
+        // 如果当前并行数量 > 0 则跳过
+        if (this._parallel > 0) {
+            return;
+        }
+        // 重试次数小于最大次数 则开始重试
+        if (this._retry < this._maxRetry) {
+            this.retryLoad();
+            return;
+        }
+        // 最终资源加载失败了
+        this.downloadFaildAnalysis();
+    }
+    /**
+     * 加载资源
+     * @internal
+     */
+    loadItem(index) {
+        let item = this.getAssetInfo(index);
+        item.status = StateType.Loading;
+        this._parallel++;
+        if (item.isFile) {
+            // 加载单个资源文件
+            AssetUtils.loadFile(item.assetBundle, item.path, item.type, {
+                complete: (asset) => {
+                    this._parallel--;
+                    item.status = StateType.Finish;
+                    AssetPool.add(asset, item.assetBundle, this._name);
+                    this.updateCompleteCount(item.bundle, item.path, 1, 1);
+                    this.loadNext();
+                },
+                fail: () => {
+                    this._parallel--;
+                    item.status = StateType.Error;
+                    this.loadNext();
+                },
+            });
+        }
+        else {
+            // 加载文件夹
+            AssetUtils.loadDir(item.assetBundle, item.path, item.type, {
+                complete: (assets) => {
+                    this._parallel--;
+                    item.status = StateType.Finish;
+                    AssetPool.add(assets, item.assetBundle, this._name);
+                    this.loadNext();
+                },
+                fail: () => {
+                    this._parallel--;
+                    item.status = StateType.Error;
+                    this.loadNext();
+                },
+                progress: (value, total) => {
+                    value > 0 &&
+                        total > 0 &&
+                        this.updateCompleteCount(item.bundle, item.path, value, total);
+                },
+            });
+        }
+    }
+    /** 重新加载失败的资源 */
+    retryDownLoadFailedAssets() {
+        this._parallel = 0;
+        this._retry = 0;
+        if (!this._initSuccess) {
+            this._retry++;
+            this.onStart();
+        }
+        else {
+            this.retryLoad();
+        }
+    }
+    /**
+     * 重试加载资源
+     * @internal
+     */
+    retryLoad() {
+        this._retry++;
+        let count = this.resetErrorAssets();
+        let maxLoad = Math.min(count, this._maxParallel);
+        for (let i = 0; i < maxLoad; i++) {
+            this.loadNext();
+        }
+    }
+}
+
+export { AssetLoader, AssetPool, AssetUtils, ErrorCode };