wgt-node-utils 0.0.6 → 0.0.7

package/dist/bundle.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgt-node-utils",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "WGT工具类包",
   "main": "dist/bundle.js",
   "scripts": {
@@ -14,18 +14,22 @@
   "author": "rookie",
   "license": "ISC",
   "dependencies": {
-    "axios": "^1.7.7",
-    "babel-loader": "^9.2.1"
+    "axios": "^1.7.7"
   },
   "devDependencies": {
     "@babel/core": "^7.25.8",
     "@babel/preset-env": "^7.25.8",
     "@eslint/js": "^9.12.0",
+    "@larksuiteoapi/node-sdk": "^1.37.2",
     "babel-cli": "^6.26.0",
+    "babel-loader": "^9.2.1",
     "cross-env": "^7.0.3",
+    "crypto-browserify": "^3.12.0",
     "eslint": "^9.12.0",
     "eslint-plugin-react": "^7.37.1",
+    "fs": "0.0.1-security",
     "globals": "^15.11.0",
+    "path": "^0.12.7",
     "typescript-eslint": "^8.9.0",
     "webpack": "^5.95.0",
     "webpack-cli": "^5.1.4"

package/src/index.js

@@ -1,10 +1,26 @@
 const axios = require('axios');
+const path = require('path');
+const fs = require('fs');
+const lark = require('@larksuiteoapi/node-sdk');
 class wgtNodeUtils {
-    constructor() {
+    constructor(appId, appSecret) {
         // 存储domain 对象
         this.domainMap = {};
         // 存储文件内容对象
         this.fileContents = {};
+        // 飞书发送工具
+        this.client = null;
+        // 存储游戏原始链接对象
+        this.gameResourcesMap = {};
+        // 是否發送错误信息开关
+        this.filesErrorSendStatus = false;
+
+         // 初始化Lark客户端
+         if (appId && appSecret) {
+            this.initClient(appId, appSecret);
+        } else {
+            console.error('Lark客户端初始化失败：未提供appId或appSecret');
+        }
     }
 
     // 获取系统信息
@@ -13,12 +29,6 @@ class wgtNodeUtils {
      * 
      */
     getSystem = (userAgent) => {
-        // 调试时获取到的数据:
-        // 'user-agent': 'Mozilla/5.0 (Linux; Android 8.0.0; SM-G955U Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Mobile Safari/537.36'
-        // 'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1',
-        //	'user-agent': 'Mozilla/5.0 (iPad; CPU OS 13_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/87.0.4280.77 Mobile/15E148 Safari/604.1',
-        // 'user-agent': 'Mozilla/5.0 (iPad; CPU OS 13_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/87.0.4280.77 Mobile/15E148 Safari/604.1',
-        // 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.83 Safari/537.36',
         const ua = userAgent;
         const isWindowsPhone = /(?:Windows Phone)/.test(ua);
         const isSymbian = /(?:SymbianOS)/.test(ua) || isWindowsPhone;
@@ -34,7 +44,10 @@ class wgtNodeUtils {
         };
     }
 
-    // 获取cloud front传回的设备信息
+    /***
+     * @headers 设备header 信息
+     * 
+     */
     getCloudFrontDevice = (headers) => {
         // cloud front逻辑
         const cfDesktop = headers['cloudfront-is-desktop-viewer'];
@@ -79,7 +92,447 @@ class wgtNodeUtils {
         }
         return device;
     }
+    // 获取cloud front传回的设备信息
+    getCloudFrontSystem = (device) => {
+        const system = {
+            isAndroid: device === 'Android',
+            isPhone: device === 'IOS',
+            isTablet: device === 'Pad'
+        };
+    
+        // 其它设备均为空的情况下，默认当前设置为pc
+        if (!system.isAndroid && !system.isPhone && !system.isTablet) {
+            system.isPC = true;
+        }
+        return system;
+    }
+
+    /***
+     * 通用头信息添加
+     * @res node端 返回头
+     * 
+     */
+    addCommonHeadersInfo = res => {
+        // 增加头信息Content-Type, 在开启gzip时会用到
+        res.setHeader('Content-Type','text/html; charset=utf-8');
+
+        // 指定被允许iframe的域名
+        res.setHeader('Content-Security-Policy','frame-ancestors https://*.enjoy4fun.com https://*.beesads.com');
+
+        // 通知浏览器应该只通过 HTTPS 访问该站点，并且以后使用 HTTP 访问该站点的所有尝试都应自动重定向到 HTTPS
+        res.setHeader('Strict-Transport-Security','max-age=63072000; includeSubDomains; preload');
+
+        // 指定客户端一定要遵循在 Content-Type 首部中对 MIME 类型 的设定
+        res.setHeader('X-Content-Type-Options','nosniff');
+
+        // 针对版本 8 及以上的 Internet Explorer，指示浏览器不要直接在浏览器中打开下载
+        res.setHeader('X-Download-Options','noopen');
+
+        // 当前页的主题标记为观察对象
+        // Topics API 的目的是为调用者（包括运行脚本的页面上的第三方广告技术或广告提供商）提供页面访问者当前可能感兴趣的粗粒度广告主题。
+        // 这些主题将补充上下文来自当前页面的信号可以组合起来以帮助为访问者找到合适的广告。
+        res.setHeader('Observe-Browsing-Topics','?1');
+    }
+    /***
+     * 获取siteId 通过hostname
+     * @url node端 返回头
+     * @hostname 网站 hostname
+     * @defaultSiteId 网站模版默认使用ID 
+     */
+    async getSiteByHostname(url, hostname, defaultSiteId) {
+        return new Promise((resolve) => {
+            let siteId = this.domainMap[hostname];
+            // 内存中存在, 使用缓存的原因是siteId与domain不会变化，而zoneMap却因为会变而不能存储
+            if (siteId) {
+                return resolve(siteId);
+            }
+    
+            axios.get(url, { params: { domain: hostname } }).then((res) => {
+                let siteData = res.data.data;
+                // 如果未获取到数据，使用enjoy4fun.com做为默认数据
+                if (!siteData) {
+                    siteId = defaultSiteId;
+                    console.log(new Date(), `获取site失败: domain=${hostname}`);
+                } else {
+                    siteId = siteData.siteId;
+                    domainMap[hostname] = siteId;
+                    console.log(new Date(), 'domainMap缓存更新', siteId, domainMap);
+                }
+                resolve(siteId);
+            });
+        });
+    }
+    /***
+     * 获取 site相关配置
+     * @isMobile 是否为移动端
+     * @url 请求后端接口
+     * @hostname 网站 hostname
+     * @imgDomain 图片地址
+     * @creativeId widget creative Id
+     */
+    // TODO 还未开发完成
+    async getSiteConfigByHostname(isMobile, url, hostname, imgDomain, creativeId, buildName) {
+        const params = {
+            domain: hostname,
+            creative_id: creativeId
+        }
+        return new Promise((resolve) => {
+            axios.get(url, { params }).then(res => {
+                let siteData = res.data.data;
+                // 如果未获取到数据，使用enjoy4fun.com做为默认数据
+                if (!siteData) {
+                    siteData = {
+                        siteId: "site_12",
+                        zoneMap: {
+                            'pad_bottom_300_250': "45330",
+                            'pad_bottom_336_280': "45326",
+                            'pc_bottom_728_90': "45320",
+                            'pc_right_300_250': "45321",
+                            'pc_right_300_600': "45322",
+                            'pc_right_300_250_2': "45324",
+                            'pc_left_160_600': "45323",
+                            'mobile_300_250_top': "45327",
+                            'mobile_300_250_mid': "45328",
+                            'mobile_300_600_bottom': "45329",
+                            'interstitial_pc': "45334",
+                            'interstitial_mobile': "45335",
+                            'pc_bottom_160_90': "45325",
+                            'pc_pad_walkthrough_336_280': "45319",
+                            'mobile_game': "45331",
+                            'pc_game': "45333",
+                            'pad_game': "45332",
+                            'sidewall': "47185"
+                        },
+                        theme: {
+                            icon: '',
+                            logo: '',
+                            title: '',
+                            bgLeftImg: '',
+                            bgRightImg: '',
+                            bgBottomImg: '',
+                        }
+                    }
+                }
+    
+                // 通过设备清洗zoneKeyMap
+                const zoneKeyList = isMobile ? mobileZoneKeyList : pcZoneKeyList;
+                let zoneMapForDevice = {};
+                const zoneMap = siteData.zoneMap || {};
+                zoneKeyList.forEach(zoneKey => {
+                    if (zoneMap[zoneKey]) {
+                        zoneMapForDevice[zoneKey] = zoneMap[zoneKey];
+                    }
+                });
+                siteData.zoneMap = zoneMapForDevice;
     
+                // 处理皮肤字段
+                const { icon, logo, title, bgLeftImg, bgRightImg, bgBottomImg, ...otherTheme }  = siteData.theme || {};
+                siteData.theme = {
+                    icon: icon ? `${imgDomain}/site_icon/${icon}` : `/${buildName}/favicon.ico`,
+                    logo: logo ? `${imgDomain}/site_logo/${logo}` : `/${buildName}/assets/logo-small.svg`,
+                    title: title || 'Enjoy4fun',
+                    bgLeftImg: bgLeftImg ? `${imgDomain}/theme/${bgLeftImg}` : '/gamebridge-web/assets/bg-left-winter.png',
+                    bgRightImg: bgRightImg ? `${imgDomain}/theme/${bgRightImg}` : '/gamebridge-web/assets/bg-right-winter.png',
+                    bgBottomImg: bgBottomImg ? `${imgDomain}/theme/${bgBottomImg}` : '/gamebridge-web/assets/bg-bottom-winter.png',
+                    ...otherTheme
+                }
+                resolve(siteData);
+            });
+        });
+    }
+
+    /***
+     * node启动时将静态资源读取到内存中
+     * @buildName 打包名称
+     * @version  打包版本号
+     * 
+     */
+    readF2eFiles = (buildName, version) => {
+        console.log('静态资源:开始读取');
+        return new Promise((resolve, reject) => {
+            try {
+                // 指定目录路径
+                const directoryPath = path.join(__dirname, `../${buildName}/${version}`);
 
+                // 读取目录下的所有文件
+                const files = fs.readdirSync(directoryPath);
+                files.forEach(file => {
+                    // 构建文件的完整路径
+                    const filePath = path.join(directoryPath, file);
+
+                    // 检查是否为文件
+                    if (fs.statSync(filePath).isFile()) {
+                        // 读取文件内容并存储到对象中
+                        this.fileContents[file] = fs.readFileSync(filePath, 'utf8');
+                    }
+                });
+                // 增加react依赖
+                this.fileContents['react.production.min.js'] = fs.readFileSync(path.join(__dirname, `../${buildName}/dist/react.production.min.js`),'utf8');
+                this.fileContents['react-dom.production.min.js'] = fs.readFileSync(path.join(__dirname, `../${buildName}/dist/react-dom.production.min.js`),'utf8');
+                this.fileContents['react-router-dom.min.js'] = fs.readFileSync(path.join(__dirname, `../${buildName}/dist/react-router-dom.min.js`),'utf8');
+
+                console.log('静态资源列表:');
+                const f2eFileLoadStatus = Object.keys(fileContents).every((item) => {
+                    const file = this.fileContents[item];
+                    console.log(item, ':', file ? file.length : 'null');
+                    return file && file.length > 0;
+                });
+                if (f2eFileLoadStatus) {
+                    resolve();
+                } else {
+                    reject();
+                }
+            } catch (e) {
+                reject();
+            }
+            console.log('静态资源:读取结束');
+        });
+    };
+     /***
+     * node启动时将静态资源读取到内存中
+     * @appId 打包名称
+     * @appSecret  打包版本号
+     * 
+     */
+    initClient = (appId, appSecret) => {
+        if (!this.client) {
+            this.client = new lark.Client({
+                appId: appId,
+                appSecret: appSecret,
+                disableTokenCache: false
+            });
+            console.log('Lark客户端初始化成功');
+        }
+    }
+    /***
+     * node启动时将静态资源读取到内存中
+     * @appId 打包名称
+     * @appSecret  打包版本号
+     * @message 发送信息值
+     * @receive_id  client 所使用的receive_id
+     */
+    sendFeiShu = (message, appId, appSecret, receive_id) => {
+        if (!this.client) {
+            if (!appId || !appSecret) {
+                console.error('Lark客户端未初始化，且未提供appId和appSecret，无法发送消息');
+                return;
+            }
+            this.initClient(appId, appSecret);
+        }
+         // 发送消息
+         this.client.im.message.create({
+            params: {
+                receive_id_type: 'chat_id',
+            },
+            data: {
+                receive_id: 'oc_aba13955509035daa7a799f30b1b3341',
+                msg_type: 'text',
+                content: `{"text":"<b>前端容器node报错</b>\\ncomponents: ${components}\\nenv: ${process.env.ENV}\\nmesssage: ${message}"}`,
+                uuid: '',
+            },
+        }).then(res => {
+            console.log('消息发送成功:', res);
+        }).catch(err => {
+            console.error('消息发送失败:', err);
+        });
+    }
+    /***
+     * node 端发送日志
+     * @text 发送文本
+     * @err  发送信息类型
+     */
+    appendLog = (title, err) => {
+        try {
+            if (!err) {
+                console.warn(`============${new Date().toLocaleString()}===========`);
+                console.warn(title);
+            }
+            else if (err.config) {
+                console.error(`============${new Date().toLocaleString()}===========`);
+                console.error(`${title} [${err.config.method}]: ${err.config.url}`);
+                console.error(`request: {params: ${JSON.stringify(err.config.params)}, data: ${JSON.stringify(err.config.data)}}`);
+                console.error(`response: ${JSON.stringify(err.response)}`);
+                this.sendFeiShu(`${title} [${err.config.method}]: ${err.config.url}`);
+            } else {
+                console.error(`============${new Date().toLocaleString()}===========`);
+                console.error(`${title} ${err}`);
+                this.sendFeiShu(`${title} ${err}`);
+            }
+        } catch (e) {
+    
+        }
+    };
+    /**
+     * 验证是否为空对像
+     * @param v 对象
+     */
+    isEmptyObj = (v) => {
+        return (
+            v === undefined ||
+            v === null ||
+            (typeof v === 'string' && v.trim() === '') ||
+            (Object.prototype.toString.apply(v) === '[object Object]' && JSON.stringify(v) === '{}') ||
+            (Array.isArray(v) && v.every(item => isEmpty(item)))
+        );
+    }
+    /**
+     * 用于渲染游戏卡列表，清理无用字段
+     * @param list 清理数组
+     */
+    clearGameCardListData = (list) => {
+        // 游戏卡片使用到的字段
+        return list.map((item = {}) => {
+            return {
+                id: item.game_id,
+                icon: item.base_icon,
+                path: item.game_path,
+                name: item.game_name,
+                icon_video: item.icon_video,
+                new: item.new ? true : undefined // 将false转换为undefined， 用于节省ssr生成的文本长度
+            }
+        });
+    }
+    /**
+     * 用于渲染类型卡片列表，清理无用字段
+     * @param list 清理数组
+     */
+    clearCategoryListData = list => {
+        return list.map((item = {}) => {
+            return {
+                id: item.id,
+                path: item.path,
+                icon: item.base_icon,
+                name: item.name
+            };
+        })
+    }
+    /**
+     * 用于渲染演练视频卡片的数据，清理无用字段
+     * @param list 清理数组
+     */
+    clearWalkThroughVideoListData = list => {
+        return list.map((item = {}) => {
+            return {
+                game_name: item.game_name,
+                game_path: item.game_path,
+                thumbnail: item.thumbnail,
+                video_id: item.video_id,
+                duration: item.duration
+            };
+        })
+    }
+    /**
+     * 拉去语言信息
+     * @param url 请求语言信息链接
+     */
+    getLanguageList = (url) => {
+        // 默认值
+        // 默认值
+        const defaultLanList = [{
+            code: 'en',
+            name: 'English',
+            icon: 'cfgv1bursfevmln3akj0.webp'
+        }]
+        return new Promise((resolve) => {
+            axios.get(url).then(res => {
+                let list = res.data.data || [];
+                // 清理无用字段
+                list = list.map(item => {
+                    return {
+                        code: item.lan,
+                        name: item.lan_name,
+                        icon: item.icon
+                    }
+                });
+                resolve(list || defaultLanList);
+            }).catch(() => {
+                this.appendLog('语言读取', '语言接口调用失败');
+                // 调用失败时，返回en
+                resolve(defaultLanList);
+            });
+        });
+    }
+    /**
+     * 游戏详情页面， 游戏资源链接替换
+     * @link 原始游戏链接
+     * @hostName 当前域名
+     * @ENV 当前环境
+     */
+    ReplaceGameResources = async (link, hostName, ENV) => {
+
+        let gameLink = '';
+        const GAME_DEFAULT_DOMAIN = 'https://game.enjoy4fun.com';
+        try {
+            let domainArr = hostName.split('.');
+            let domain = domainArr.slice(-2).join('.');
+            let gameDomain = this.gameResourcesMap[domain];
+    
+            // 当前没有map 中没有存储新的 domain，创建新的map
+            if (!gameDomain) {
+                gameDomain = `https://game.${domain}`;
+                const isAvailable = await checkDomainAvailability(gameDomain);
+                if (isAvailable) {
+                    console.log('gameDomain可用，使用新的域名')
+                    this.gameResourcesMap[domain] = gameDomain;
+                } else {
+                    console.log('gameDomain不可用，使用默认域名')
+                    this.gameResourcesMap[domain] = GAME_DEFAULT_DOMAIN;
+                    gameDomain = GAME_DEFAULT_DOMAIN;
+                }
+            }
+    
+            // 当前游戏domain 为默认游戏域名
+            if (gameDomain === GAME_DEFAULT_DOMAIN) {
+                console.log(new Date(), 'gameResourcesMap:存在且等于默认游戏名使用默认link', this.gameResourcesMap,'link', link);
+                return link;
+            }
+    
+            // 替换游戏链接
+            if (ENV.includes('prod') || ENV.includes('qa')) {
+                gameLink = link.replace(GAME_DEFAULT_DOMAIN, gameDomain);
+            }
+            console.log(new Date(), 'gameResourcesMap:存在使用替换新的域名', this.gameResourcesMap, 'gameDomain', gameDomain, 'gameLink', gameLink);
+            return gameLink;
+        } catch (error) {
+            gameLink = link;
+        }
+    
+        return gameLink;
+    };
+    /**
+     * 获取前端静态资源
+     * @pageName 页面名称
+     * @isMobile 是否为移动端
+     */
+    getModelF2eFiles = (pageName, isMobile) => {
+        let jsName = `${pageName}.entry.js`;
+        let cssName = `${pageName}.entry.css`;
+        // 带设备信息的静态资源
+        if (typeof isMobile === 'boolean') {
+            const device = isMobile ? 'mobile' : 'pc';
+            jsName = `${pageName}-${device}.entry.js`;
+            cssName = `${pageName}-${device}.entry.css`;
+        }
+        const f2eFiles = {
+            jsStr: fileContents[jsName],
+            cssStr: fileContents[cssName],
+            reactStr: fileContents['react.production.min.js'],
+            reactDomStr: fileContents['react-dom.production.min.js'],
+            reactRouterStr: fileContents['react-router-dom.min.js'],
+        };
+        // 每次启动服务后仅对第一次失败进行验证
+        if (!this.filesErrorSendStatus) {
+            const fileStatus = Object.keys(f2eFiles).every(item => {
+                let file = f2eFiles[item];
+                if (file && file.length > 0) {
+                    return true;
+                }
+                this.appendLog(`${pageName}[${item}]`, '文件加载失败');
+                return false;
+            });
+            this.filesErrorSendStatus = !fileStatus;
+        }
+        return f2eFiles;
+    }
 }
 module.exports = new wgtNodeUtils();

package/webpack.config.js

@@ -1,12 +1,12 @@
 // webpack.config.js
 const path = require('path');
-
+const webpack = require('webpack');
 module.exports = {
   entry: './src/index.js', // 入口文件
   output: {
     path: path.resolve(__dirname, 'dist'),
     filename: 'bundle.js', // 输出的文件名
-    library: 'wgtUtils', // 暴露库名
+    library: 'wgtNodeUtils', // 暴露库名
     libraryTarget: 'umd', // 使用 UMD 规范
     globalObject: 'this'
   },
@@ -21,5 +21,12 @@ module.exports = {
       }
     ]
   },
-  mode: 'production' // 生产模式，优化打包
+  mode: 'production', // 生产模式，优化打包
+  resolve: {
+    fallback: {
+      fs: false, // 告诉 Webpack 不需要处理 fs 模块
+      crypto: false,
+      querystring: false
+    },
+  },
 };