@foxpage/foxpage-manager/lib/material/manager.js

foxpage resource manager

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MaterialManagerImpl = void 0;
const foxpage_shared_1 = require("@foxpage/foxpage-shared");
const common_1 = require("../common");
const data_service_1 = require("../data-service");
const material_1 = require("./material");
/**
 * material manager
 *
 * @export
 * @class MaterialManager
 * @extends {ManagerBaseImpl}
 */
class MaterialManagerImpl extends common_1.ManagerBaseImpl {
    constructor(app) {
        super(app, { type: 'material', diskCache: { enable: true } });
        /**
         * content id & fileId+locale map
         *
         * @private
         */
        this.contentMap = new Map();
    }
    /**
     * add material to manager
     *
     * @param {Material} material
     */
    addMaterial(material) {
        this.logger.info(`add material@${material.id}`);
        this.logger.debug(`add material@${material.id}, detail:`, JSON.stringify(material));
        const newVar = this.newMaterial(material);
        this.addMaterialKeys(material);
        const { fileId } = material;
        if (!fileId) {
            this.logger.warn(`add material@${material.id} failed, fileId is empty`);
        }
        else {
            this.addOne(material.id, material, newVar);
        }
        return newVar;
    }
    /**
     * remove local material via materialKeys
     *
     * @param {string[]} materialKeys
     */
    removeMaterials(materialKeys) {
        const { materialIds } = this.getMaterialIds(materialKeys);
        this.remove(materialIds);
        this.removeMaterialKeys(materialKeys);
    }
    /**
     * get material from local first, not exist will fetch from server
     *
     * @param {string} materialFileIds fileId
     * @param {Record<string, any>} opt contain locale
     * @return {*}  {(Promise<Material | undefined>)}
     */
    async getMaterial(materialFileIds, opt) {
        return (await this.getMaterials([materialFileIds], opt))[0];
    }
    /**
     * get materials
     *
     * @param {string[]} materialFileIds fileIds
     * @param {Record<string, any>} opt contain locale
     * @return {*}  {Promise<Material[]>}
     */
    async getMaterials(materialFileIds, opt) {
        const { locale } = opt || {};
        const materialKeys = materialFileIds.map(id => {
            return foxpage_shared_1.material.generateKey(id, locale);
        });
        const { materialIds, emptyKeys } = this.getMaterialIds(materialKeys);
        let list = [];
        if (emptyKeys.length > 0) {
            list = await this.freshMaterials(emptyKeys);
        }
        const cacheList = await this.find(materialIds);
        list = list.concat(cacheList);
        return list;
    }
    /**
     * fetch application material
     */
    async freshMaterials(materialKey) {
        const items = materialKey.map(key => {
            const { fileId, locale } = foxpage_shared_1.material.parseKey(key);
            return { id: fileId, locale };
        });
        // fetch materials from server bt fileId + locale s
        const materials = await data_service_1.foxpageDataService.fetchMaterials(this.appId, { items });
        return materials.map(material => {
            return this.addMaterial(material);
        });
    }
    async onFetch(list) {
        // fetch materials from server by materialIds
        const materials = await data_service_1.foxpageDataService.fetchMaterials(this.appId, { materialIds: list });
        return materials.map(material => {
            return this.addMaterial(material);
        });
    }
    async onPull(data) {
        // update & removes material keys: fileId@locale
        const { updates, removes } = data.material || {};
        if (updates && updates.length > 0) {
            const { materialIds, existKeys } = this.getMaterialIds(updates);
            const contentIds = await this.filterExists(materialIds);
            if (contentIds.length > 0) {
                this.markNeedUpdates(contentIds);
            }
            if (existKeys.length > 0) {
                await this.freshMaterials(updates);
            }
        }
        if (removes && removes.length > 0) {
            this.removeMaterials(removes);
        }
    }
    onStash(data) {
        var _a;
        (_a = data.materials) === null || _a === void 0 ? void 0 : _a.map(material => {
            this.addMaterial(material);
        });
    }
    async createInstance(data) {
        return this.newMaterial(data);
    }
    newMaterial(data) {
        return new material_1.MaterialInstance(data);
    }
    addMaterialKeys(material) {
        const { fileId, locale } = material;
        if (fileId) {
            const key = foxpage_shared_1.material.generateKey(fileId, locale);
            this.contentMap.set(key, material.id);
        }
    }
    removeMaterialKeys(materialKeys) {
        materialKeys.forEach(key => {
            this.contentMap.delete(key);
        });
    }
    getMaterialIds(keys) {
        const materialIds = [];
        const emptyKeys = [];
        const existKeys = [];
        keys.forEach(key => {
            const materialId = this.contentMap.get(key);
            if (materialId) {
                materialIds.push(materialId);
                existKeys.push(key);
            }
            else {
                emptyKeys.push(key);
            }
        });
        return { materialIds, emptyKeys, existKeys };
    }
    destroy() {
        super.destroy();
        this.contentMap.clear();
    }
}
exports.MaterialManagerImpl = MaterialManagerImpl;