基本框架提交

f6cac901 · 章志富 · 2fa83cc8 · f6cac901 · f6cac901 · f6cac901
Commit f6cac901 authored Dec 13, 2021 by 章志富
57 changed files
--- a/MD.js
+++ b/MD.js
+import MD from 'spark-utils/out/md/index.js';
+let appId = CFG.appID;
+const dcm = '202.' + CFG.projectId + '.0.0';
+// const dom = CFG.channel + '.0.0.0'
+const domain = '//embedlog.duiba.com.cn';
+// 总埋点数据，包含所有埋点号
+let rawList = [];
+for (let index = 1; index <= 4; index++) {
+  rawList.push({
+    ele: `.md${index}`,
+    data: {
+      dpm: `${appId}.110.${index}.1`,
+      dcm,
+      // dom,
+      domain,
+      appId,
+    },
+    once: false,
+    index: index
+  });
+}
+// 不需要自动曝光埋点的索引
+const noShowIndexs = [];
+// 不需要自动点击埋点的索引
+const noClickIndexs = []
+// 曝光埋点列表
+const showList = rawList.filter(v1 => !noShowIndexs.some(v2 => v2 == v1.index))
+// 点击埋点列表
+const clickList = rawList.filter(v1 => !noClickIndexs.some(v2 => v2 == v1.index))
+// console.log('showList',showList);
+// console.log('clickList',clickList);
+export default () =>
+  MD({
+    show: showList, // 曝光
+    click: clickList // 点击
+  });
--- a/README.md
+++ b/README.md
-# yinlian_20211213
+## 项目大雁文档地址
+## 项目后端技术方案地址
+## 项目前端技术方案地址
--- a/config/scripts/assets/generateAssetList.js
+++ b/config/scripts/assets/generateAssetList.js
+/*
+将此文件放到project/config/scripts/assets/目录下
+在package.json文件的"scripts"字段下，分别修改dev和build命令：
+"dev": "node ./config/scripts/assets/generateAssetList.js && node ./config/webpack.dev.config.js"
+"build": "node ./config/scripts/assets/generateAssetList.js && node ./config/scripts/assets/index.js imgmin imgup && node ./config/webpack.prod.config.js"
+*/
+const fs = require('fs');
+/** 预加载资源文件夹正则 */
+// const preloadFolderRegExp = require('../../../sparkrc.js').PRELOAD_ASSET_MATCH;
+const preloadFolderRegExp = /\/(.+)\//; // 要匹配所有的资源，写/\/(.+)\//
+/** 合法资源正则 */
+const assetRegExp = /\.(png|jpg|jpeg|svga|spi|json|mp3|wav)$/i;
+// 读资源目录
+const [preloadAsset, otherAsset] = searchFileFromFolder('./src/assets', [
+    { 
+        folderRegExp: preloadFolderRegExp, 
+        fileRegExp: assetRegExp
+    }
+]);
+console.log('assetList', preloadAsset, otherAsset);
+// 写资源列表json
+fs.writeFileSync(
+    './src/assetList.json', 
+    JSON.stringify({
+        preloadAsset: preloadAsset.map(v => v.replace("./src/assets/", '')), 
+        otherAsset: otherAsset.filter(v => assetRegExp.test(v)).map(v => v.replace("./src/assets/", '')),
+    })
+);
+/**
+ * 搜索文件夹里的文件
+ * @param {string} folderPath 文件夹地址，相对路径
+ * @param {object[]} ruleList 规则列表，例[{folderRegExp: /\/(index|game)\//, fileRegExp: /.(png|jpg)$/}]
+ * @returns {string[]} 返回文件相对路径地址
+ */
+function searchFileFromFolder(folderPath, ruleList) {
+    if (!fs.existsSync(folderPath)) {
+        console.warn('searchFileFromFolder', folderPath, '路径不存在');
+        return;
+    }
+    if (!fs.statSync(folderPath).isDirectory()) {
+        console.warn('searchFileFromFolder', folderPath, '不是文件夹');
+        return;
+    }
+    /** 最后输出的资源路径列表 */
+    const pathList = [];
+    for (let index = 0; index < ruleList.length + 1; index++) pathList.push([]);
+    /** 递归查找方法 */
+    const searchOneDir = (folderPath) => {
+        fs.readdirSync(folderPath).forEach(content => {
+            const secondaryPath = folderPath + '/' + content;
+            if(fs.statSync(secondaryPath).isFile()) {
+                // 文件匹配
+                let isMatched = false;
+                ruleList.forEach((v, i) => {
+                    // 目录及文件匹配
+                    if (v.folderRegExp.test(secondaryPath) && v.fileRegExp.test(secondaryPath)) {
+                        pathList[i].push(secondaryPath);
+                        isMatched = true;
+                    }
+                })
+                !isMatched && pathList[pathList.length - 1].push(secondaryPath);
+            }else {
+                searchOneDir(secondaryPath);
+            }
+        });
+    }
+    searchOneDir(folderPath);
+    // console.warn('pathList', pathList);
+    return pathList;
+}
--- a/config/scripts/assets/index.js
+++ b/config/scripts/assets/index.js
+const { assets } = require("spark-assets");
+const args = process.argv.splice(2);
+let argsObj = {
+  imgmin: false,
+  imgup: false
+}
+if (args.length == 1) {
+  argsObj.imgmin = 'imgmin' == args[0];
+  argsObj.imgup = 'imgup' == args[0];
+} else if (args.length == 2) {
+  argsObj.imgmin = 'imgmin' == args[0];
+  argsObj.imgup = 'imgup' == args[1];
+}
+assets(argsObj)
\ No newline at end of file
--- a/config/scripts/constant.js
+++ b/config/scripts/constant.js
+exports.SPARK_CONFIG_DIR_KEY = ['OUTPUT_DIR', 'SOURCE_DIR', 'TEMP_DIR', 'ENTRY', 'TEMPLATE']
+exports.SPARK_CONFIG = 'sparkrc.js'
+//对应项目在线素材存储的cdn配置，用于迭代开发从线上拉取素材到本地
+exports.SPARK_CDN_RES_CFG='sparkrescfg.json'
\ No newline at end of file
--- a/config/scripts/loaders/replaceLoader.js
+++ b/config/scripts/loaders/replaceLoader.js
+const loaderUtils = require('loader-utils');
+module.exports = function (source) {
+  const options = loaderUtils.getOptions(this);
+  let result = source;
+  if (options.arr) {
+    options.arr.map(op => {
+      result = result.replace(op.replaceFrom, op.replaceTo);
+    })
+  } else {
+    result = source.replace(options.replaceFrom, options.replaceTo);
+  }
+  return result
+};
--- a/config/scripts/plugins/HtmlJsToES5Plugin.js
+++ b/config/scripts/plugins/HtmlJsToES5Plugin.js
+const babel = require('@babel/core');
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+class HtmlJsToES5Plugin {
+	process(htmlPluginData) {
+		return new Promise(function (resolve) {
+			const scriptRegExp = /<script>[\s\S]*?<\/script>/gis;
+			htmlPluginData.html = htmlPluginData.html.replace(scriptRegExp, function (match) {
+				const code = match.replace("<script>", "").replace("</script>", "");
+				const es5Code = babel.transform(code, { 'presets': ['@babel/preset-env'] }).code;
+				return `<script>${es5Code}</script>`;
+			});
+			resolve();
+		});
+	};
+	apply(compiler){
+		compiler.hooks.compilation.tap('HtmlJsToES5Plugin', (compilation) => {
+			HtmlWebpackPlugin.getHooks(compilation).afterTemplateExecution.tapAsync(
+				"HtmlJsToES5Plugin",
+				async (html, cb) => {
+					await this.process(html);
+					cb(null, html);
+				}
+			);
+		});
+	}
+}
+// exports.default = HtmlJsToES5Plugin;
+module.exports = HtmlJsToES5Plugin;
--- a/config/scripts/utils.js
+++ b/config/scripts/utils.js
+// 端口是否被占用
+exports.getProcessIdOnPort=function(port) {
+    try {
+        const execOptions = {
+            encoding: 'utf8',
+            stdio: [
+                'pipe',
+                'pipe',
+                'ignore',
+            ],
+        };
+        return execSync('lsof -i:' + port + ' -P -t -sTCP:LISTEN', execOptions)
+            .split('\n')[0]
+            .trim();
+    } catch (e) {
+        return null;
+    }
+}
+const childProcessSync=async function(cmd, params, cwd, printLog = true) {
+    return new Promise((resolve, reject) => {
+        let proc = childProcess(cmd, params, cwd, printLog);
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve(proc['logContent']);
+            } else {
+                reject(code);
+            }
+        });
+    });
+}
+const getGitBranch=async function(cwd) {
+    try {
+        const result = await childProcessSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd, false);
+        if (!result.startsWith('fatal:')) {
+            return result.trim();
+        }
+    } catch (e) {
+        return undefined;
+    }
+}
+const getProjectNameByPackage=function() {
+    return require(`${process.cwd()}/package.json`).name
+}
+/**
+ * 理论上每个项目独一无二的文件夹名字-默认取分支名
+ * 如果当前未创建分支，取包名+日期
+ * （实际很多情况是直接clone老项目，包名相同，以防资源被替换，所以用日期加一下）
+ */
+exports.getCdnFolderName=async function() {
+    const branch = await getGitBranch(process.cwd());
+    const date = Date.now();
+    if (branch) {
+        return branch + "/" + date;
+    }
+    let foldername = getProjectNameByPackage() + "/" + date;
+    return foldername;
+}
\ No newline at end of file
--- a/config/webpack.common.config.js
+++ b/config/webpack.common.config.js
+const path = require('path');
+const fs = require("fs");
+const { SPARK_CONFIG_DIR_KEY, SPARK_CONFIG } = require('./scripts/constant');
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+const MiniCssExtractPlugin = require("mini-css-extract-plugin");
+const { CleanWebpackPlugin } = require("clean-webpack-plugin");
+const TerserPlugin = require("terser-webpack-plugin");
+const OptimizeCSSAssetsPlugin = require("optimize-css-assets-webpack-plugin");
+const ProgressBarPlugin = require("progress-bar-webpack-plugin");
+module.exports = function (isProd) {
+    const appPath = process.cwd();
+    const sparkConfig = require(path.join(appPath, SPARK_CONFIG));
+    const isEslint = fs.existsSync(`${appPath}/.eslintrc.js`);
+    const cssReg = /\.(css|less)$/;
+    // 处理相对路径
+    SPARK_CONFIG_DIR_KEY.map((key) => {
+        sparkConfig[key] = path.resolve(appPath, sparkConfig[key]);
+    });
+    const stylePlugins = [
+        require("autoprefixer")({
+            overrideBrowserslist: ["> 1%", "last 2 versions", "not ie <= 8"],
+        })
+    ];
+    if (sparkConfig.PX2REM) {
+        stylePlugins.push(
+            require("postcss-px2rem-exclude")({
+                remUnit: 100, // 注意算法，这是750设计稿，html的font-size按照750比例
+                exclude: /node_modules/i,
+            })
+        );
+    }
+    const styleLoader = (cssOptions = {}) => {
+        return [
+            {
+                loader: "style-loader",
+            },
+            isProd && {
+                loader: MiniCssExtractPlugin.loader,
+                options: {
+                    esModule: false,
+                },
+            },
+            {
+                loader: "css-loader",
+                options: {
+                    ...cssOptions,
+                    importLoaders: 2, // 如果遇到css里面的 @import 执行后面两个loader。 不然如果import了less，css-loader是解析不了
+                },
+            },
+            {
+                loader: "postcss-loader",
+                options: {
+                    sourceMap: isProd,
+                    plugins: stylePlugins,
+                },
+            },
+            {
+                loader: require.resolve("less-loader"),
+                options: {
+                    sourceMap: isProd,
+                    lessOptions: {
+                        modifyVars: {
+                            "@RES_PATH": `"${isProd ? sparkConfig.RES_PATH_PROD + '/' : sparkConfig.RES_PATH}"`,
+                        },
+                    }
+                },
+            },
+        ].filter(Boolean);
+    };
+    return {
+        entry: sparkConfig.ENTRY,
+        mode: isProd ? 'production' : 'development',
+        devtool: isProd ? "source-map" : "cheap-module-source-map",
+        output: {
+            path: path.resolve(__dirname, sparkConfig.OUTPUT_DIR),
+            filename: "js/[name].js",
+        },
+        resolve: {
+            extensions: ['.js', '.jsx', '.json'],
+            alias: {
+                "@src": path.resolve(__dirname, sparkConfig.SOURCE_DIR),
+            },
+        },
+        module: {
+            rules: [
+                // 提前进行eslint, 默认从下往上，通过enforce pre提前
+                isEslint && {
+                    test: /\.js|jsx/,
+                    enforce: "pre",
+                    loader: "eslint-loader",
+                    options: {
+                        cache: true,
+                        formatter: require("eslint-friendly-formatter"),
+                        fix: true,
+                        failOnError: true,
+                        configFile: `${appPath}/.eslintrc.js`,
+                    },
+                    include: sparkConfig.SOURCE_DIR,
+                },
+                {
+                    test: cssReg,
+                    use: styleLoader(),
+                    include: sparkConfig.SOURCE_DIR,
+                },
+                {
+                    test: /\.(js|jsx)$/,
+                    loader: require.resolve("babel-loader"),
+                    exclude: [path.resolve("node_modules")],
+                    options: {
+                        presets: [
+                            require("@babel/preset-env").default,
+                            require("@babel/preset-react").default
+                        ],
+                        plugins: [
+                            ["@babel/plugin-proposal-decorators", { "legacy": true }],
+                            ["@babel/plugin-proposal-class-properties", { "loose": false }],
+                            require("@babel/plugin-transform-runtime").default,
+                        ],
+                        sourceType: 'unambiguous'
+                    },
+                },
+                {
+                    test: [/\.(jpg|jpeg|png|svg|bmp)$/, /\.(eot|woff2?|ttf|svg)$/],
+                    loader: require.resolve("url-loader"),
+                    options: {
+                        name: "[path][name].[ext]", // name默认是加上hash值。这里做了更改，不让加
+                        outputPath: "images",
+                        limit: 10240, // url-loader处理图片默认是转成base64, 这里配置如果小于10kb转base64,否则使用file-loader打包到images文件夹下
+                    },
+                },
+            ].filter(Boolean),
+        },
+        plugins: [
+            isProd &&
+            new MiniCssExtractPlugin({
+                filename: "styles/[name].[hash].css",
+            }),
+            new HtmlWebpackPlugin({
+                template: sparkConfig.TEMPLATE,
+                minify: !sparkConfig.UNMINIFY_INDEX && isProd,
+            }),
+            new CleanWebpackPlugin({
+                // cleanOnceBeforeBuildPatterns:['**/*', 'dist'] // 这里不用写 是默认的。 路径会根据output 输出的路径去清除
+            }),
+            new ProgressBarPlugin(),
+        ].filter(Boolean),
+        optimization: {
+            minimize: isProd,
+            minimizer: [
+                // 替换的js压缩 因为uglifyjs不支持es6语法，
+                new TerserPlugin({
+                    cache: true,
+                    sourceMap: isProd,
+                    extractComments: false, // 提取注释
+                    parallel: true, // 多线程
+                    terserOptions: {
+                        compress: {
+                            pure_funcs: ["console.log"],
+                        },
+                    },
+                }),
+                // 压缩css
+                new OptimizeCSSAssetsPlugin({
+                    assetNameRegExp: /\.optimize\.css$/g,
+                    cssProcessor: require("cssnano"),
+                    cssProcessorPluginOptions: {
+                        preset: ["default", { discardComments: { removeAll: true } }],
+                    },
+                    canPrint: true,
+                }),
+            ],
+            // 修改文件的ids的形成方式，避免单文件修改，会导致其他文件的hash值变化，影响缓存
+            moduleIds: "hashed",
+            splitChunks: {
+                chunks: "all",
+                minSize: 30000, //小于这个限制的会打包进Main.js
+                cacheGroups: {
+                    vendors: {
+                        test: /[\\/]node_modules[\\/]/,
+                        priority: -10, // 优先级权重，层级 相当于z-index。 谁值越大权会按照谁的规则打包
+                        name: "vendors",
+                    },
+                },
+            },
+            // chunks 映射关系的 list单独从 app.js里提取出来
+            runtimeChunk: {
+                name: (entrypoint) => `runtime-${entrypoint.name}`,
+            },
+        },
+    };
+}
\ No newline at end of file
--- a/config/webpack.dev.config.js
+++ b/config/webpack.dev.config.js
+const { SPARK_CONFIG } = require("./scripts/constant");
+const Webpack = require("webpack");
+const webpackBaseConfig = require("./webpack.common.config");
+const WebpackMerge = require("webpack-merge");
+const WebpackDevServer = require("webpack-dev-server");
+const opn = require("opn");
+const apiMocker = require('mocker-api');
+const path = require('path');
+const { getProcessIdOnPort } = require("./scripts/utils");
+const sparkConfig = require(path.resolve(SPARK_CONFIG));
+const webpackDevConfig = function () {
+  return {
+    devServer: {
+      useLocalIp: true,
+      open: false,
+      hot: true,
+      host: "0.0.0.0",
+      // hotOnly: true
+      before(app) {
+        if (sparkConfig.API_MOCK) {
+          apiMocker(app, path.resolve('./mock/index.js'), {
+            changeHost: true,
+          })
+        }
+      }
+    },
+    plugins: [
+      // new Webpack.WatchIgnorePlugin([/[\\/]mock[\\/]/]),
+      new Webpack.HotModuleReplacementPlugin()
+    ]
+  };
+};
+const buildDev = async function (config) {
+  let { port } = config;
+  return new Promise((resolve, reject) => {
+    const config = WebpackMerge(webpackBaseConfig(false), webpackDevConfig());
+    const compiler = Webpack(config);
+    const devServerOptions = Object.assign({}, config.devServer);
+    console.log('devServerOptions', devServerOptions);
+    const server = new WebpackDevServer(compiler, devServerOptions);
+    if (getProcessIdOnPort(port)) {
+      reject(`端口 ${port} 已被使用`);
+      return;
+    } else {
+      server.listen(
+        port || 8088,
+        "0.0.0.0",
+        () => {
+          console.log(`Starting server on http://localhost:${port}`);
+          opn(`http://localhost:${port || 8088}`);
+          resolve();
+        },
+        (err) => {
+          if (err) console.error("server linsten err--", err);
+          reject();
+        }
+      );
+    }
+  });
+};
+const args = process.argv.splice(2);
+const port = args[0] || 8088
+buildDev({
+  port: Number(port)
+})
--- a/config/webpack.prod.config.js
+++ b/config/webpack.prod.config.js
+const path = require("path");
+const chalk = require("chalk");
+const fs = require('fs-extra');
+const Webpack = require("webpack");
+const WebpackMerge = require("webpack-merge");
+const webpackBaseConfig = require("./webpack.common.config");
+const { uploadFiles } = require("spark-assets");
+const isProd = true;
+const { getCdnFolderName } = require("./scripts/utils");
+const { SPARK_CONFIG } = require("./scripts/constant");
+const HtmlJsToES5Plugin = require("./scripts/plugins/HtmlJsToES5Plugin");
+const { DepReporter } =require('spark-log-event');
+const sparkConfig = require('../sparkrc');
+const ScriptExtHtmlWebpackPlugin = require("script-ext-html-webpack-plugin");
+const webpackProdConfig = function (cdnFolderName, resPathProd) {
+  return {
+    output: {
+      publicPath: `//yun.duiba.com.cn/spark/v2/${cdnFolderName}/`,
+      filename: isProd ? "js/[name].[contenthash:8].js" : "js/[name].[contenthash:4].js",
+    },
+    resolveLoader: {
+      modules: ['node_modules', path.resolve(__dirname, './scripts/loaders')]
+    },
+    module: {
+      rules: [
+        {
+          test: /sparkrc\.js$/,
+          exclude: [path.resolve("node_modules")],
+          use: [
+            {
+              loader: 'replaceLoader',
+              options: {
+                arr: [
+                  {
+                    replaceFrom: /(MOCK_STATUS: true)|(MOCK_STATUS:true)|("MOCK_STATUS": true)|("MOCK_STATUS":true)/,
+                    replaceTo: '"MOCK_STATUS": false'
+                  },
+                  {
+                    replaceFrom: /(RES_PATH:'\/src\/assets\/')|(RES_PATH: '\/src\/assets\/')|("RES_PATH":"\/src\/assets\/")|("RES_PATH": "\/src\/assets\/")/,
+                    replaceTo: `"RES_PATH":"${resPathProd}/"`
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    plugins: [
+      new Webpack.IgnorePlugin(/[\\/]mock[\\/]/),
+      new ScriptExtHtmlWebpackPlugin({
+        custom: {
+          test: /\.js$/,
+          attribute: 'crossorigin',
+          value: 'anonymous'
+        }
+      }),
+      new HtmlJsToES5Plugin(),
+      new DepReporter()
+    ],
+    node: {
+      crypto: 'empty'
+    }
+  };
+};
+const buildProd = async function () {
+  const cdnFolderName = await getCdnFolderName();
+  const appPath = process.cwd();
+  const sparkConfig = require(path.join(appPath, SPARK_CONFIG));
+  const _webpackProdConfig = await webpackProdConfig(cdnFolderName, sparkConfig.RES_PATH_PROD || '');
+  //新增 JS_PATH_PROD 用作
+  let newSparkCfg = Object.assign({}, sparkConfig);
+  newSparkCfg['JS_PATH_PROD'] = `https://yun.duiba.com.cn/spark/v2/${cdnFolderName}/js`;
+  const str = `module.exports =${JSON.stringify(newSparkCfg, null, 2)}`;
+  fs.writeFileSync(path.join(appPath, SPARK_CONFIG), str);
+  return new Promise((resolve, reject) => {
+    const config = WebpackMerge(webpackBaseConfig(isProd), _webpackProdConfig);
+    const compiler = Webpack(config);
+    compiler.run(async (error, stats) => {
+      if (error) {
+        return reject(error);
+      }
+      console.log(
+        stats.toString({
+          chunks: false, // 使构建过程更静默无输出
+          colors: true, // 在控制台展示颜色
+        })
+      );
+      console.log(`${chalk.yellow("打包成功, 等待上传")}\n`);
+      // await uploadFiles(config.output.path, '', cdnFolderName);
+      await uploadFiles(config.output.path, '', cdnFolderName, /.map$/);
+      // 上传map到不同路径，避免泄漏源码
+      await uploadFiles(
+          config.output.path + "/js",
+          'js/map_123_map',
+          cdnFolderName,
+          /.(js|css|css\.map)$/
+      );
+      resolve();
+    });
+  });
+};
+buildProd();
--- a/jsconfig.json
+++ b/jsconfig.json
+{
+  "compilerOptions": {
+    "jsx": "react",
+    "experimentalDecorators": true,
+    "baseUrl": "./",
+    "paths": {
+      "@src/*": ["src/*"]
+    }
+  },
+  "exclude": [
+      "node_modules"
+  ]
+}
\ No newline at end of file
--- a/loc.json
+++ b/loc.json
+{"numOfComponents":1356,"numOfProject":734}
\ No newline at end of file
--- a/mock/common/hydPlayWay_index.js
+++ b/mock/common/hydPlayWay_index.js
+module.exports = {
+  "GET /hydPlayWay/index.do": {
+    "success": true,
+    "code": "ad officia laboris ipsum",
+    "data": {
+      "couponActivityState": 1,
+      "redPacketActivityState": 1,
+      "ddgActivityState": 1,
+      "couponLink": "https://www.baidu.com?id=couponLink",
+      "redpacketLink": "https://www.baidu.com?id=redpacketLink",
+      "ddgLink": "https://www.baidu.com?id=ddgLink"
+    }
+  }
+}
\ No newline at end of file
--- a/mock/common/rule.js
+++ b/mock/common/rule.js
+module.exports = {
+  "GET /projectRule.query": {
+    "data": "<p>一、规则内容</p><p></p><p>1、除活动规则另有规定外，每次活动中，每个用户只限参加一次活动，每个用户只能中奖一次。同一手机、同一联系方式、同一IP地址、同一支付宝账户、同一身份证件、同一银行卡号、同一收货地址、同一终端设备号或其他可以合理显示为同一用户的情形，均视为同一用户。</p><p></p><p>2、用户参加活动的时间、秒杀到或拍下商品的时间及次序、支付款项的时间及次序，均以支付宝系统记录的时间为准（如有）。</p><p></p><p>3、除活动规则另有规定外，用户应自行负担因参与活动领取奖品（包括但不限于奖金、红包、集分宝、收益、实物）而产生的税费（如有）。</p><p></p><p>4、活动结束后或活动规则中约定的奖品发放时间结束后（以两者中时间较晚的为准）的10个工作日内，活动举办方未能联系上获奖用户且此期间获奖用户未向活动举办方主张奖品的，视为获奖用户放弃奖品，活动举办方无义务再为用户发放奖品。</p><p></p><p>5、活动期间，如发现有用户通过不正当手段（包括但不限于侵犯第三人合法权益、作弊、扰乱系统、实施网络攻击、恶意套现、刷信誉、批量注册、用机器注册支付宝账户、用机器模拟客户端）参加活动而有碍其他用户公平参加本次活动或有违反活动目的之行为，活动举办方有权取消该用户获奖资格或取消、追回该用户通过参加活动所获赠品或权益。如该作弊行为给活动举办方造成损失的，活动举办方保留向该用户追究赔偿的权利。</p><p></p><p>6、活动期间，任何用户不得使用任何装置、软件或程序干预或试图干预活动举办方平台的正常运作或正在该平台上进行的任何交易、活动。任何用户不得采取任何将导致不合理的庞大数据负载加诸活动举办方平台网络设备的行动。</p><p></p><p>7、活动期间，如遭遇自然灾害、网络攻击或系统故障、有权部门要求暂停、变更或终止活动等不可抗拒因素导致活动暂停、变更或停止的，活动举办方无需承担赔偿责任或进行补偿。</p><p>&nbsp</p><p>8、在参加活动之前，请您认真阅读本规则及具体活动中展示的规则，一旦您参与活动的，即视为您同意活动所涉及的所有活动规则。如您对活动规则有任何异议，请您不要继续参与活动。</p><br/><p>9、活动奖品由合作商家提供的，奖品以及服务质量由合作商家负责。奖品为实物的，活动所有奖品以实物为准，照片和奖品说明仅供参考</p>",
+    "success": true
+  }
+}
\ No newline at end of file
--- a/mock/index.js
+++ b/mock/index.js
+const fs = require('fs')
+let mockData = {};
+fs.readdirSync(__dirname + '/common').forEach(v => {
+  Object.assign(mockData, require('./common/' + v))
+});
+// console.log('mockData',mockData)
+module.exports = mockData;
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
+{
+  "name": "temp_base",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "dev": "node ./config/scripts/assets/generateAssetList.js && node ./config/webpack.dev.config.js 8109",
+    "imgmin": "node ./config/scripts/assets/index.js imgmin",
+    "imgup": "node ./config/scripts/assets/index.js imgup",
+    "imgminup": "node ./config/scripts/assets/index.js imgmin imgup",
+    "prod": "node ./config/webpack.prod.config.js",
+    "build": "node ./config/scripts/assets/index.js imgmin imgup && node ./config/webpack.prod.config.js"
+  },
+  "dependencies": {
+    "@spark/animation": "2.0.52",
+    "@spark/api-base": "2.0.33",
+    "@spark/chary": "1.0.31",
+    "@spark/popup": "3.0.3",
+    "@spark/projectx": "2.0.13",
+    "@spark/share": "2.0.170",
+    "@spark/ui": "2.0.36",
+    "@spark/utils": "2.0.53",
+    "axios": "0.19.2",
+    "css-loader": "3.6.0",
+    "duiba-utils": "1.0.2",
+    "fyge": "^3.0.4",
+    "history": "4.10.1",
+    "howler": "^2.2.3",
+    "mobx": "6.2.0",
+    "mobx-react": "7.1.0",
+    "postcss-loader": "3.0.0",
+    "prettier": "2.0.5",
+    "qs": "6.9.4",
+    "react": "17.0.2",
+    "react-dom": "17.0.2",
+    "react-redux": "7.2.4",
+    "react-router-dom": "5.2.1",
+    "redux": "4.1.1",
+    "redux-thunk": "2.3.0",
+    "spark-utils": "0.0.12",
+    "style-loader": "1.2.1"
+  },
+  "devDependencies": {
+    "@babel/core": "7.12.10",
+    "@babel/plugin-transform-runtime": "7.12.10",
+    "@babel/plugin-proposal-decorators": "7.13.15",
+    "@babel/preset-env": "7.12.11",
+    "@babel/preset-react": "7.12.10",
+    "autoprefixer": "9.8.6",
+    "babel-loader": "8.2.2",
+    "chalk": "4.1.0",
+    "clean-webpack-plugin": "3.0.0",
+    "eslint-loader": "4.0.2",
+    "fs-extra": "9.0.1",
+    "html-webpack-plugin": "4.5.1",
+    "less": "4.1.0",
+    "less-loader": "7.2.1",
+    "mini-css-extract-plugin": "1.3.4",
+    "mocker-api": "2.7.5",
+    "mockjs": "1.1.0",
+    "optimize-css-assets-webpack-plugin": "5.0.4",
+    "postcss-px2rem-exclude": "0.0.6",
+    "progress-bar-webpack-plugin": "2.1.0",
+    "spark-assets": "1.1.9",
+    "url-loader": "4.1.1",
+    "webpack": "4.43.0",
+    "webpack-cli": "4.3.1",
+    "webpack-dev-server": "3.11.0",
+    "webpack-merge": "4.2.2",
+    "spark-log-event": "1.0.4"
+  }
+}
--- a/public/favicon.ico
+++ b/public/favicon.ico
--- a/public/index.html
+++ b/public/index.html
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+  <meta name="theme-color" content="#000000">
+  <title>lc-template</title>
+  <script src="//yun.duiba.com.cn/spark/v2/spark.base.fz.wxpollyfill.js"></script>
+  <script src="//yun.duiba.com.cn/js-libs/rem/1.1.3/rem.min.js"></script>
+  <script src="//yun.duiba.com.cn/h5/lib/zepto.min.js"></script>
+  <!-- 动态域名 -->
+  <script src="//yun.duiba.com.cn/js-libs/dbdomain/1.0.25/dbdomain.js"></script>
+  <!-- 微信sdk -->
+  <!-- <script src="//res.wx.qq.com/open/js/jweixin-1.4.0.js"></script> -->
+  <!-- vconsole -->
+  <!-- <script src="//yun.duiba.com.cn/js-libs/vConsole/3.3.4/vconsole.min.js"></script> -->
+  <script>
+    // var vConsole = new VConsole();
+    // 打印当前链接
+    console.warn('page url', location.href);
+    var CFG = CFG || {};
+    CFG.appID = '${APPID}';
+    CFG.projectId = location.pathname.split('/')[2] || '1';
+    CFG.pageID = 'index'; // index-首页 | share-分享落地页;
+    CFG.shareConfig = {
+      title: 'title', //分享标题
+      content: 'content', //分享内容
+      url: 'url', //分享链接，见src/share.js里的处理
+      thumbnail: 'https://yun.duiba.com.cn/aurora/assets/72fe2b57cb9b4bcfe35e2d525c50d4b831920fd4.png', //分享缩略图
+    }
+    function getUrlParam(name) {
+      var search = window.location.search;
+      var matched = search
+        .slice(1)
+        .match(new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i'));
+      return search.length ? matched && matched[2] : null;
+    }
+    // 打印CFG
+    console.warn('CFG', CFG);
+  </script>
+</head>
+<body>
+  <noscript>
+    You need to enable JavaScript to run this app.
+  </noscript>
+  <div id="root"></div>
+  <!--
+      This HTML file is a template.
+      If you open it directly in the browser, you will see an empty page.
+      You can add webfonts, meta tags, or analytics to this file.
+      The build step will place the bundled scripts into the <body> tag.
+      To begin the development, run `npm start` or `yarn start`.
+      To create a production bundle, use `npm run build` or `yarn build`.
+    -->
+</body>
+</html>
--- a/sparkrc.js
+++ b/sparkrc.js
+module.exports ={
+  /** 正则表达式，匹配.src/asset目录下需要预加载资源的文件夹 */
+  "PRELOAD_ASSET_MATCH": /\/(test)\//, 
+  "OUTPUT_DIR": "dist",
+  "SOURCE_DIR": "src",
+  "TEMP_DIR": "./.temp",
+  "ENTRY": "src/app.jsx",
+  "TEMPLATE": "./public/index.html",
+  "API_MOCK": true,
+  "PX2REM": true,
+  "IMAGE_Q1": 0.6,
+  "IMAGE_Q2": 0.8,
+  "RES_PATH": "/src/assets/",
+  "RES_PATH_PROD": "//yun.duiba.com.cn/spark/v2/temp_base/1624936160970"
+}
\ No newline at end of file
--- a/src/api/apicfg.js
+++ b/src/api/apicfg.js
+const apiCfg = {
+  getRule: {
+    uri: `projectRule.query`,
+    method: "get",
+    // showMsg: false,
+    // showLoading: true,
+  },
+  hydPlayWay_index: {
+    uri: `hydPlayWay/index.do`,
+    method: "get"
+  },
+}
+export default apiCfg;
--- a/src/api/index.js
+++ b/src/api/index.js
+import apiCfg from './apicfg';
+import { getPxToken } from "@spark/projectx";
+import { callApi } from '@spark/api-base'
+import { isFromShare, newUser } from 'duiba-utils';
+import { Loading } from '@spark/ui'
+import { Global } from '../global.js'
+let mergeData = {
+	user_type: newUser ? '0' : '1',
+	is_from_share: isFromShare ? '0' : '1',
+}
+const apiList = {
+	...apiCfg
+}
+const API = generateAPI(apiList);
+export default API;
+function getRequestParams(value) {
+	if (typeof value === 'string') {
+		return {
+			uri: value,
+			method: 'get'
+		}
+	} else if (typeof value === 'object') {
+		const { uri, method = 'get', headers, withToken, secret, secretKey, contentType = 'form', showLoading = false, showMsg = true } = value;
+		return {
+			uri,
+			method,
+			headers,
+			withToken,//是否传入token
+			secret,
+			secretKey,
+			contentType,
+			showLoading,// 是否展示loading
+			showMsg,// 是否自动处理success:false并抛出msg
+		}
+	} else {
+		console.error('getRequestParams: 传参有误');
+	}
+}
+export function generateAPI(apiList) {
+	const api = {};
+	let isTokenRequestResponded = true;//用于标记带token的接口是否响应完毕
+	for (let key in apiList) {
+		let value = apiList[key];
+		let { method, uri, headers: mHeaders, withToken, secret, secretKey, contentType, showLoading, showMsg } = getRequestParams(value);
+		api[key] = async (params = {}, headers) => {
+			showLoading && Loading.show();// 根据接口配置showLoading展示loading
+			let token;
+			if (withToken) {
+				if (isTokenRequestResponded) {//上一个带token的接口响应完毕，则把新的带token的接口请求标记为尚未响应
+					isTokenRequestResponded = false;
+				} else {//上一个带token的接口尚未响应完毕，则停止新的带token的接口的请求
+					console.warn('上一个带token的接口尚未响应完毕，已停止新的带token的接口的请求，原因可能是：1.接口防连点未做好 2.弱网环境（延迟比防连点时长还高）的连续请求')
+					return
+				}
+				try {
+					token = await getPxToken();
+				} catch (e) {
+					isTokenRequestResponded = true;// 网络异常时置为true，保证网络恢复时能正常请求带token的接口
+					Global.Itoast('网络异常!')
+					showLoading && Loading.hide();// 根据接口配置showLoading关闭loading
+					return;
+				}
+			}
+			let mergedHeaders = { ...mHeaders, ...headers }
+			if (withToken && token) {
+				params.token = token;
+			}
+			params = { ...params, ...mergeData };
+			const result = await callApi(uri, params, method, mergedHeaders, false, secret, secretKey, contentType)
+				.catch(e => {
+					// 捕获网络异常
+					Global.Itoast('网络异常~')
+				});
+			showLoading && Loading.hide();// 根据接口配置showLoading关闭loading
+			if (withToken && token) {//带token的接口响应完毕
+				isTokenRequestResponded = true;
+			}
+			if (result) {// 网络正常，拿到了响应数据
+				if (result.success) {// success:true
+					return result; // return响应结果，用then拿数据
+				} else {// success:false
+					// 判断接口配置showMsg
+					if (showMsg) {// 自动处理，toast出后端msg，不用写catch也不会触发catch
+						Global.Itoast(result.message || '网络异常');
+					} else {// 手动处理，throw响应结果，用catch拿数据
+						throw result;
+					}
+				}
+			}
+		}
+	}
+	return api;
+}
--- a/src/app.jsx
+++ b/src/app.jsx
+import React, { Component } from "react";
+import ReactDOM from "react-dom";
+import "./app.less";
+import MD from '../MD';
+import { Popup, showPop, hidePop } from '@spark/popup'
+import Page_index from './pages/page_index/comp'
+// import Page_share from './pages/Page_share/Page_share'
+import { Global } from './global'
+Global.showPop = showPop;
+Global.hidePop = hidePop;
+MD();
+//此处为spark-cli动态生成
+class App extends Component {
+  render() {
+    return (
+      <>
+        {/* 弹窗组件，写在前面，保证其后组件能立即使用其弹窗方法 */}
+        <Popup />
+        {/* 首页 */}
+        {CFG.pageID == 'index' && <Page_index />}
+        {/* 分享落地页 */}
+        {/* {CFG.pageID == 'share' && <Page_share />} */}
+      </>
+    );
+  }
+}
+ReactDOM.render(<App />, document.getElementById("root"));
--- a/src/app.less
+++ b/src/app.less
+* {
+  margin: 0;
+  padding: 0;
+  -webkit-touch-callout: none;  /*ios禁用Safari展示callout*/
+  -webkit-user-select: none; /* Safari */
+  -ms-user-select: none; /* IE 10+ and Edge */
+  user-select: none; /* Standard syntax */
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0); //防止点击出现半透明灰色背景
+}
+input {
+  //保证文字可选，否则可能影响输入框输入
+  -webkit-user-select: text !important; /* Safari */
+  -ms-user-select: text !important; /* IE 10+ and Edge */
+  user-select: text !important; /* Standard syntax */
+}
+html,
+body {
+  font-size: 24px;
+  width: 100%;
+  height: 100%;
+  -webkit-text-size-adjust: 100% !important;
+  text-size-adjust: 100% !important;
+  -moz-text-size-adjust: 100% !important;
+}
+#root{
+  width: 750px;
+  height: 100%;
+  overflow: hidden;
+  position: fixed;
+  background-color: #fff;
+}
+// 设置元素可点击
+.can_click {
+  pointer-events: auto;
+}
+// 设置元素点击穿透
+.click_through {
+  pointer-events: none;
+}
+@keyframes up_down {
+  0% {transform: translateY(0px)}
+  50% {transform: translateY(-20px)}
+  100% {transform: translateY(0px)}
+}
+@keyframes rotate_light {
+  0% {transform: rotate(0deg)}
+  100% {transform: rotate(360deg)}
+}
+@keyframes big_small {
+  0% {transform: scale(1)}
+  50% {transform: scale(1.1)}
+  100% {transform: scale(1)}
+}
+// 弹窗由下向上弹出 animation: popup_from_bottom 250ms ease-in-out;
+@keyframes popup_from_bottom {
+  0% {
+    transform: translateY(100%);
+  }
+  100% {
+    transform: translateY(0%);
+  }
+}
\ No newline at end of file
--- a/src/assetList.json
+++ b/src/assetList.json
+{"preloadAsset":["test/btn_roll.png","test/coin.mp3","test/cow_spine.spi","test/finger.svga","test/smoke.json"],"otherAsset":[]}
\ No newline at end of file
--- a/src/assets/test/btn_roll.png
+++ b/src/assets/test/btn_roll.png
--- a/src/assets/test/coin.mp3
+++ b/src/assets/test/coin.mp3
--- a/src/assets/test/cow_spine.spi
+++ b/src/assets/test/cow_spine.spi
--- a/src/assets/test/finger.svga
+++ b/src/assets/test/finger.svga
--- a/src/assets/test/smoke.json
+++ b/src/assets/test/smoke.json
+{"v":"5.6.10","fr":30,"ip":0,"op":99,"w":262,"h":367,"nm":"炊烟袅袅","ddd":0,"assets":[{"id":"image_0","w":1070,"h":306,"u":"","p":"data:image/png;base64,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","e":1},{"id":"image_1","w":634,"h":204,"u":"","p":"data:image/png;base64,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","e":1}],"layers":[{"ddd":0,"ind":1,"ty":2,"nm":"cloud_1.png","cl":"png","refId":"image_0","sr":1,"ks":{"o":{"a":1,"k":[{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":24,"s":[0]},{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":30,"s":[100]},{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":76,"s":[90]},{"t":90,"s":[0]}],"ix":11},"r":{"a":1,"k":[{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.345],"y":[0.011]},"t":30,"s":[-58]},{"t":90,"s":[-99]}],"ix":10},"p":{"a":1,"k":[{"i":{"x":0.833,"y":0.833},"o":{"x":0.167,"y":0.167},"t":30,"s":[40.943,333.618,0],"to":[36.5,-12.833,0],"ti":[-23.5,45.833,0]},{"t":90,"s":[156.943,235.618,0]}],"ix":2},"a":{"a":0,"k":[909.086,60.211,0],"ix":1},"s":{"a":1,"k":[{"i":{"x":[0.833,0.833,0.833],"y":[0.833,0.833,0.833]},"o":{"x":[0.167,0.167,0.167],"y":[0.167,0.167,0.167]},"t":24,"s":[-2.353,4,100]},{"i":{"x":[0.833,0.833,0.833],"y":[0.833,0.833,0.833]},"o":{"x":[0.167,0.167,0.167],"y":[0.167,0.167,0.167]},"t":30,"s":[-5.882,10,100]},{"t":90,"s":[-21.176,36,100]}],"ix":6}},"ao":0,"ip":24,"op":390,"st":30,"bm":0},{"ddd":0,"ind":2,"ty":2,"nm":"cloud_2.png","cl":"png","refId":"image_1","sr":1,"ks":{"o":{"a":1,"k":[{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":0,"s":[0]},{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":6,"s":[86]},{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":52,"s":[80]},{"t":66,"s":[0]}],"ix":11},"r":{"a":1,"k":[{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":6,"s":[-1]},{"t":66,"s":[-33]}],"ix":10},"p":{"a":1,"k":[{"i":{"x":0.833,"y":0.833},"o":{"x":0.167,"y":0.167},"t":6,"s":[26.5,321.75,0],"to":[31.333,-7.5,0],"ti":[-15.333,27,0]},{"t":66,"s":[113.5,265.25,0]}],"ix":2},"a":{"a":0,"k":[33.015,191.912,0],"ix":1},"s":{"a":1,"k":[{"i":{"x":[0.833,0.833,0.833],"y":[0.833,0.833,0.833]},"o":{"x":[0.167,0.167,0.167],"y":[0.167,0.167,0.167]},"t":0,"s":[10,20,100]},{"i":{"x":[0.833,0.833,0.833],"y":[0.833,0.833,0.833]},"o":{"x":[0.167,0.167,0.167],"y":[0.167,0.167,0.167]},"t":6,"s":[16,32,100]},{"t":66,"s":[42,80,100]}],"ix":6}},"ao":0,"ip":0,"op":366,"st":6,"bm":0}],"markers":[]}
\ No newline at end of file
--- a/src/components/comp_fyge_canvas/comp.jsx
+++ b/src/components/comp_fyge_canvas/comp.jsx
+'use strict';
+import { Global } from '@src/global';
+import * as FYGE from 'fyge';
+import React, { useEffect, useState } from 'react';
+import './comp.less';
+export {
+  Comp_fyge_canvas,
+  addClick,
+  createContainer,
+  createTxt,
+  createImg,
+  createSvga,
+  createSpine,
+  createLottie,
+}
+/**
+ * 使用fyge引擎操作的canvas组件
+ * @param {object} props
+ * @param {Function} [props.onStageReady] stage准备好了回调，回调入参为stage实例
+ */
+function Comp_fyge_canvas({ onStageReady }) {
+  const [that] = useState({});
+  // 生成stage
+  useEffect(() => {
+    console.warn('Comp_fyge_canvas init');
+    const canvas = that.canvas;
+    //建舞台
+    const stage = new FYGE.Stage(
+      canvas,//canvas画布
+      750,//设计宽度，按设计搞给的就行
+      1624,//设计高度
+      canvas.getBoundingClientRect().width,//显示宽度，css宽度
+      canvas.getBoundingClientRect().height,//显示高度，css高度
+      FYGE.RENDERER_TYPE.WEBGL,//2d上下文
+      false,//舞台是否居中，false不居中左上置顶，true居中小于1624或750的视窗会上下或左右平均裁切
+      false,//是否定高，默认否（定宽）
+      window.devicePixelRatio || 1
+    );
+    //鼠标事件
+    const mouseEvent = stage.onMouseEvent.bind(stage);
+    stage.webMouseEventPreventDefault = true;
+    stage.webMouseEventStopPropagation = true;
+    canvas.addEventListener("touchstart", mouseEvent, false);
+    canvas.addEventListener('touchmove', mouseEvent, false);
+    canvas.addEventListener('touchend', mouseEvent, false);
+    //stage初始化事件
+    stage.addEventListener(FYGE.Event.INIT_STAGE, () => onStageReady?.(stage));
+    //每帧循环起来
+    const loop = () => {
+      FYGE.Tween.flush()
+      stage.flush();
+      that.requestID = window.requestAnimationFrame(loop);
+    }
+    loop();
+    return () => {
+      //Tween都移除，
+      FYGE.Tween.removeAllTweens()
+      //计时器取消
+      window.cancelAnimationFrame(that.requestID);
+      //舞台销毁
+      stage.destroy();
+    }
+  }, [])
+  return (
+    <canvas className="fyge_canvas" ref={ref => that.canvas = ref}></canvas>
+  );
+}
+/**
+ * 添加点击事件
+ * @param {*} node displayObject
+ * @param {Function} onClick 点击回调函数
+ * @param {*} data 点击事件携带数据，可通过event.target.__data获取
+ */
+function addClick(node, onClick, data = null) {
+  node.__data = data;
+  node.removeEventListener(FYGE.MouseEvent.CLICK, onClick);
+  node.addEventListener(FYGE.MouseEvent.CLICK, onClick);
+}
+/**
+ * 创建容器
+ * @param {object} option 
+ */
+function createContainer({
+  x = 0,
+  y = 0,
+  width = 0,
+  height = 0,
+  color,
+  colorOpacity = 0.3,
+  visible = true,
+  onCreated,
+}) {
+  const container = new FYGE.Container();
+  container.position.set(x, y);
+  container.width = width;
+  container.height = height;
+  container.visible = visible;
+  if (color) {
+    container.addChild(new FYGE.Graphics())
+      .beginFill(color, colorOpacity)
+      .drawRect(0, 0, width, height)
+      .endFill();
+  }
+  onCreated?.(container);
+  return container
+}
+/**
+ * 创建文字
+ * @param {object} option 
+ */
+function createTxt({
+  text = '', //显示的文字内容
+  x = 0,
+  y = 0,
+  color = "#000000", //文本颜色
+  size = 16, //文字大小
+  width, //文字的宽度
+  height, //文字的高度
+  align = 'left', //文字的对齐方式
+  strokeColor, //文本的描边颜色
+  stroke, //描边的宽度
+  visible = true,
+  onCreated
+}) {
+  const txt = new FYGE.TextField();
+  txt.text = text;
+  txt.position.set(x, y);
+  txt.fillColor = color;
+  txt.size = size;
+  width && (txt.textWidth = width);
+  height && (txt.textHeight = height);
+  txt.textAlign = align;
+  strokeColor && (txt.strokeColor = strokeColor);
+  stroke && (txt.stroke = stroke);
+  txt.visible = visible;
+  onCreated?.(txt);
+  return txt
+}
+/**
+ * 创建图片
+ * @param {object} option 
+ */
+function createImg({
+  path,
+  x = 0,
+  y = 0,
+  scaleX = 1,
+  scaleY = 1,
+  visible = true,
+  onCreated
+}) {
+  const img = new FYGE.Sprite(FYGE.Texture.fromImage(Global.assetData[path]));
+  img.position.set(x, y);
+  img.scaleX = scaleX;
+  img.scaleY = scaleY;
+  img.visible = visible;
+  onCreated?.(img);
+  return img
+}
+/**
+ * 创建svga
+ * @param {object} option 
+ */
+function createSvga({
+  path,
+  x = 0,
+  y = 0,
+  scaleX = 1,
+  scaleY = 1,
+  autoPlay = true,
+  loop = 0,
+  onEnd,
+  mouseEnable = false,
+  visible = true,
+  onCreated,
+}) {
+  const svga = new FYGE.MovieClip(Global.assetData[path]); //创建svga对象
+  svga.visible = visible;
+  svga.position.set(x, y); //设置svga位置
+  svga.scaleX = scaleX;
+  svga.scaleY = scaleY;
+  if (autoPlay) {
+    svga.startAniRange(0, svga.totalFrames, loop, () => onEnd?.());
+  } else {
+    svga.stop();
+  }
+  svga.mouseEnable = mouseEnable;
+  svga.mouseChildren = mouseEnable;
+  onCreated?.(svga);
+  return svga
+}
+/**
+ * 创建spine
+ * @param {object} option 
+ */
+function createSpine({
+  path,
+  x = 0,
+  y = 0,
+  scaleX = 1,
+  scaleY = 1,
+  autoPlay = true,
+  skinName,
+  aniName,
+  loop = 0,
+  onEnd,
+  mouseEnable = false,
+  visible = true,
+  onCreated,
+}) {
+  const spine = new FYGE.Spine(Global.assetData[path])
+  spine.visible = visible;
+  spine.position.set(x, y);
+  spine.scaleX = scaleX;
+  spine.scaleY = -scaleY;
+  skinName && spine.setSkin(skinName);
+  console.log("skinName", spine);
+  if (autoPlay && aniName) {
+    spine.animationManager.showAni(aniName, loop, () => onEnd?.());
+  }
+  spine.mouseEnable = mouseEnable;
+  spine.mouseChildren = mouseEnable;
+  onCreated?.(spine);
+  return spine
+}
+/**
+ * 创建lottie
+ * @param {object} option 
+ */
+ function createLottie({
+  path,
+  x = 0,
+  y = 0,
+  scaleX = 1,
+  scaleY = 1,
+  autoPlay = true,
+  loop = 0,
+  onEnd,
+  mouseEnable = false,
+  visible = true,
+  onCreated,
+}) {
+  const lottie = new FYGE.Lottie(Global.assetData[path])
+  lottie.visible = visible;
+  lottie.position.set(x, y);
+  lottie.scaleX = scaleX;
+  lottie.scaleY = scaleY;
+  if (autoPlay) {
+    lottie.play(loop, () => onEnd?.());
+  }
+  lottie.mouseEnable = mouseEnable;
+  lottie.mouseChildren = mouseEnable;
+  onCreated?.(lottie);
+  return lottie
+}
--- a/src/components/comp_fyge_canvas/comp.less
+++ b/src/components/comp_fyge_canvas/comp.less
+.fyge_canvas {
+  position: absolute;
+  width: 750px;
+  height: 1624px;
+  pointer-events: auto;
+}
--- a/src/components/rule_for_test/comp.jsx
+++ b/src/components/rule_for_test/comp.jsx
+'use strict';
+import React, { Component } from 'react';
+import API from '../../api';
+import './comp.less';
+class Rule_for_test extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      rule: ''
+    }
+  }
+  async componentDidMount() {
+    API.getRule().then(rsp => {
+      if (rsp) {
+        this.setState({ rule: rsp.data });
+      }
+    })
+    // let rsp = await API.getRule();
+    // if (rsp) {
+    //   this.setState({ rule: rsp.data });
+    // }
+  }
+  render() {
+    return (
+      <div className="pop_rule ">
+        <span onClick={()=>this.props.showPop({popName: 'RuleTest', isCenter: true, isClickBlankHide: true, zIndex: 1, maskOpacity: 0.3})} className="title ">游戏规则</span>
+        <div className="view">
+          <div className="text_rule " dangerouslySetInnerHTML={{ __html: this.state.rule }}></div>
+        </div>
+      </div>
+    );
+  }
+}
+export default Rule_for_test;
--- a/src/components/rule_for_test/comp.less
+++ b/src/components/rule_for_test/comp.less
+.pop_rule {
+  width: 610px;
+  height: 625px;
+  left: 70px;
+  top: 500px;
+  position: absolute;
+  background-color: white;
+  border-radius: 20px;
+  .title {
+    width: 610px;
+    top: 40px;
+    position: absolute;
+    font-size: 40px;
+    text-align: center;
+    color: black;
+  }
+  .view {
+    width: 540px;
+    height: 450px;
+    left: 49px;
+    top: 126px;
+    overflow: scroll;
+    position: absolute;
+    .text_rule {
+      position: absolute;
+      width: 522px;
+      font-size: 28px;
+      color: #333333;
+      word-wrap: break-word;
+    }
+  }
+  .btn_close {
+    width: 26px;
+    height: 26px;
+    right: 20px;
+    top: 20px;
+    position: absolute;
+  }
+}
--- a/src/constant.js
+++ b/src/constant.js
+export {
+    SceneId
+}
+/** 场景id */
+const SceneId = {
+    /** 无 */
+    DEFAULT: 0,
+    /** 主场景 */
+    MAIN: 1,
+}
\ No newline at end of file
--- a/src/global.js
+++ b/src/global.js
+export { Global }
+import { 
+    Itoast, 
+    GetUrlParams, 
+    SendLog, 
+    InputController, 
+    DoEveryTime, 
+    ProcessleftSecond, 
+    CopyTxt, 
+    TimerController,
+    PreloadAsset,
+    ProcessTimestamp,
+    SetElementStyle,
+    BenchAPI,
+    WaitTime,
+    OnVisibilityChange,
+} from './lib/index.js'
+let Global = {
+    Itoast,
+    GetUrlParams,
+    SendLog,
+    Throttle: (new InputController()).throttle_control,
+    DoEveryTime,
+    ProcessleftSecond,
+    CopyTxt,
+    TimerController,
+    PreloadAsset,
+    ProcessTimestamp,
+    SetElementStyle,
+    BenchAPI,
+    WaitTime,
+    OnVisibilityChange,
+}
--- a/src/lib/TimerController.js
+++ b/src/lib/TimerController.js
+export { TimerController }
+/** 
+ * 定时器类
+ */
+class TimerController {
+    /** 存储标记的定时id */
+    signedIdMap = {}
+    /** 未标记的定时id列表 */
+    unsignedIdList = []
+    /**
+     * 定时执行一个方法
+     * @param {Function} fn 定时调用的方法
+     * @param {number} [time] 定时时间
+     * @param {string} [sign] 定时标记，执行时会先清除之前的同标记定时——意思是如果传入标记那么该定时只会同时存在一个
+     * @returns {number} timer id
+     */
+    start = (fn, time, sign)=>{
+        sign && clearTimeout(sign);
+        let id = setTimeout(fn, time);
+        sign ? this.signedIdMap[sign] = id : this.unsignedIdList.push(id);
+        return id
+    }
+    /**
+     * 按标记清除定时，有则清除，没有也无副作用
+     * @param {string} sign 定时标记
+     */
+    clear = (sign)=>{
+        this.signedIdMap[sign] && clearTimeout(this.signedIdMap[sign]);
+    }
+    /**
+     * 清除所有定时
+     */
+    clearAll = ()=>{
+        Object.keys(this.signedIdMap).forEach(v => clearTimeout(this.signedIdMap[v]));
+        this.unsignedIdList.forEach(v => clearTimeout(v));
+    }
+}
\ No newline at end of file
--- a/src/lib/checkUa.js
+++ b/src/lib/checkUa.js
+export { GetAndroidVersion, GetIosVersion, isWx, isWxMini }
+/**
+ * 获取安卓版本号
+ * @param {string} [ua] 
+ */
+function GetAndroidVersion(ua) {
+    ua = (ua || navigator.userAgent).toLowerCase();
+    var match = ua.match(/android\s([0-9\.]*)/);
+    return match ? match[1] : false;
+}
+/**
+ * 获取ios版本号
+ * @param {string} [ua] 
+ */
+function GetIosVersion(ua) {
+    ua = (ua || navigator.userAgent).toLowerCase();
+    var match = ua.match(/cpu iphone os (.*?) like mac os/);
+    return match ? match[1] : false;
+}
+/**
+ * 判断是否是微信环境
+ */
+function isWx() {
+    return !!navigator.userAgent.match(/MicroMessenger/i)
+}
+/**
+ * 判断是否是微信小程序环境
+ * @example 
+ * // 引入：
+ * <script type="text/javascript" src="//res.wx.qq.com/open/js/jweixin-1.6.0.js"></script>
+ * // 判断：
+ * let result = await isWxMini()
+ */
+function isWxMini() {
+    return new Promise((resolve)=>{
+        wx.miniProgram.getEnv((res) => {
+            res.miniprogram ? resolve(true) : resolve(false)
+        })
+    })
+}
\ No newline at end of file
--- a/src/lib/generateAssetList.js
+++ b/src/lib/generateAssetList.js
+/*
+将此文件放到project/config/scripts/assets/目录下
+在package.json文件的"scripts"字段下，分别修改dev和build命令：
+"dev": "node ./config/scripts/assets/generateAssetList.js && node ./config/webpack.dev.config.js"
+"build": "node ./config/scripts/assets/generateAssetList.js && node ./config/scripts/assets/index.js imgmin imgup && node ./config/webpack.prod.config.js"
+*/
+const fs = require('fs');
+/** 预加载资源文件夹正则，用于匹配./src/assets目录下的文件夹 */
+const preloadFolderRegExp = /\/(test)\//; // 要匹配所有的资源，写/\/(.+)\//
+/** 合法资源正则 */
+const assetRegExp = /\.(png|jpg|jpeg|svga|spi|json|mp3|wav)$/i;
+// 读资源目录
+const [preloadAsset, otherAsset] = searchFileFromFolder('./src/assets', [
+    { 
+        folderRegExp: preloadFolderRegExp, 
+        fileRegExp: assetRegExp
+    }
+]);
+// console.log('assetList', preloadAsset, otherAsset);
+// 写资源列表json
+fs.writeFileSync(
+    './src/assetList.json', 
+    JSON.stringify({
+        preloadAsset: preloadAsset.map(v => v.replace("./src/assets/", '')), 
+        otherAsset: otherAsset.filter(v => assetRegExp.test(v)).map(v => v.replace("./src/assets/", '')),
+    })
+);
+/**
+ * 搜索文件夹里的文件
+ * @param {string} folderPath 文件夹地址，相对路径
+ * @param {object[]} ruleList 规则列表，例[{folderRegExp: /\/(index|game)\//, fileRegExp: /.(png|jpg)$/}]
+ * @returns {string[]} 返回文件相对路径地址
+ */
+function searchFileFromFolder(folderPath, ruleList) {
+    if (!fs.existsSync(folderPath)) {
+        console.warn('searchFileFromFolder', folderPath, '路径不存在');
+        return;
+    }
+    if (!fs.statSync(folderPath).isDirectory()) {
+        console.warn('searchFileFromFolder', folderPath, '不是文件夹');
+        return;
+    }
+    /** 最后输出的资源路径列表 */
+    const pathList = [];
+    for (let index = 0; index < ruleList.length + 1; index++) pathList.push([]);
+    /** 递归查找方法 */
+    const searchOneDir = (folderPath) => {
+        fs.readdirSync(folderPath).forEach(content => {
+            const secondaryPath = folderPath + '/' + content;
+            if(fs.statSync(secondaryPath).isFile()) {
+                // 文件匹配
+                let isMatched = false;
+                ruleList.forEach((v, i) => {
+                    // 目录及文件匹配
+                    if (v.folderRegExp.test(secondaryPath) && v.fileRegExp.test(secondaryPath)) {
+                        pathList[i].push(secondaryPath);
+                        isMatched = true;
+                    }
+                })
+                !isMatched && pathList[pathList.length - 1].push(secondaryPath);
+            }else {
+                searchOneDir(secondaryPath);
+            }
+        });
+    }
+    searchOneDir(folderPath);
+    // console.warn('pathList', pathList);
+    return pathList;
+}
--- a/src/lib/index.js
+++ b/src/lib/index.js
+export * from './sendLog.js'
+export * from './wrap.js'
+export * from './kit.js'
+export * from './inputController.js'
+export * from './checkUa.js'
+export * from './timerController.js'
+export * from './preload.js'
\ No newline at end of file
--- a/src/lib/inputController.js
+++ b/src/lib/inputController.js
+export { InputController }
+/**
+ * 输入控制类，用于节流（可防连点）和防抖控制
+ */
+class InputController {
+    /**
+     * 节流控制方法
+     * @param {string} sign 控制的标记，不同控制用不同的sign，建议写方法名
+     * @param {number} [time] 控制的时间，默认1500ms，为0则一直控制，直到通过相应sign来解除控制
+     * @returns {boolean} 要控制 = true | 不控制 = false
+     * @example 
+     * //防连点：
+     * onClick = {() => throttle_control('doSomething1') || doSomething1()}
+     * //手动开关：
+     * onClick = {() => throttle_control('doSomething2', 0) || doSomething2()}
+     * //第一次点击可以正常走到doSomething2()，后续点击走不到，通过执行下面代码来解除控制：
+     * throttle_control['doSomething2'] = false;
+     */
+    throttle_control = (sign, time = 1500) => {
+        if (this.throttle_control[sign]) {
+            return true;
+        } else {
+            this.throttle_control[sign] = true;
+            if (time) {
+                setTimeout(() => {
+                    this.throttle_control[sign] = false;
+                }, time);
+            }
+            return false;
+        }
+    }
+    /**
+     * 节流改造方法
+     * @param {function} fn 要节流的方法
+     * @param {number} time 间隔时间，默认1500ms
+     * @returns {function} 带有节流功能的方法，由fn改造而来
+     * @example 
+     * //把目标方法doSomething1改造成自带节流功能的方法doSomething2
+     * doSomething2 = throttle_reform(doSomething1);
+     */
+    throttle_reform = (fn, time = 1500) => {
+        let sign = false;
+        return function throttleFn() {
+            if (!sign) {
+                sign = true;
+                fn();
+                setTimeout(() => {
+                    sign = false;
+                }, time);
+            }
+        }
+    }
+    /**
+     * 防抖控制方法
+     * @param {string} sign 控制的标记
+     * @param {number} [time] 控制的时间，默认为500ms
+     * @example
+     * //input输入框onChange回调防抖：
+     * onChange = {async () => await debounce_control('doSomething1') || doSomething1()}
+     */
+    debounce_control = (sign, time = 500) => {
+        let isRelease = false;//记录promise是否释放
+        return new Promise((resolve)=>{
+            this.debounce_control[sign] && clearTimeout(this.debounce_control[sign]);
+            this.debounce_control[sign] = setTimeout(() => {
+                resolve(false);
+            }, time);
+            setTimeout(() => {
+                if (!isRelease) {//未释放则释放
+                    resolve(true);
+                }
+            }, time + 20);
+        })
+    }
+    /**
+     * 防抖改造方法
+     * @param {function} fn 要防抖的方法
+     * @param {number} time 间隔时间，默认500ms
+     * @returns {function} 带有防抖功能的方法，由fn改造而来
+     */
+    debounce_reform = (fn, time = 500) => {
+        let timer = null
+        return function () {
+            timer && clearTimeout(timer)
+            timer = setTimeout(() => {
+                fn();
+            }, time)
+        }
+    }
+}
\ No newline at end of file
--- a/src/lib/kit.js
+++ b/src/lib/kit.js
+export  {
+    ProcessTimestamp,
+    ProcessleftSecond,
+    GetUrlParams,
+    SetElementStyle,
+    DoEveryTime,
+    CopyTxt,
+    CalcHourInterval,
+    GetDayIndex,
+    WaitTime,
+    OnVisibilityChange,
+    EaseNum,
+}
+/**
+ * 监听页面可见性变化
+ * @param {Function} onVisible 页面变可见回调
+ * @param {Function} onHidden 页面变隐藏回调
+ */
+function OnVisibilityChange(onVisible, onHidden) {
+    document.addEventListener( "visibilitychange" , () => {
+        document.visibilityState == "visible" && onVisible?.();
+        document.visibilityState == "hidden" && onHidden?.();
+    });
+}
+/**
+ * 等待一段时间
+ * @param {number} time 等待的时间ms
+ */
+function WaitTime(time) {
+    return new Promise(resolve => setTimeout(resolve, time))
+}
+/**
+ * 计算两个时间戳之间间隔的整点数
+ * @param {number} startTimestamp 
+ * @param {number} endTimestamp 
+ * @returns {number} hours
+ */
+function CalcHourInterval(startTimestamp, endTimestamp) {
+    if (startTimestamp > endTimestamp) {
+        console.warn('CalcHourInterval','入参有误！！！ startTimestamp 应该比 endTimestamp 小');
+        return 0;
+    }
+    let hours = Math.floor((endTimestamp - startTimestamp) / 3600000);
+    if (endTimestamp % 3600000 < startTimestamp % 3600000) {
+        hours += 1;
+    }
+    return hours
+}
+/**
+ * 复制字符串到剪贴板
+ * @param {string} txt 要复制到剪贴板的字符串
+ * @param {Function} [success] 成功回调
+ * @param {Function} [fail] 失败回调
+ */
+function CopyTxt(txt, success, fail){
+    console.log('尝试复制', txt);
+    var textarea = document.createElement('textarea');
+    textarea.readOnly = 'readonly'
+    textarea.style.position = 'absolute'
+    textarea.style.left = '100%'
+    textarea.value = txt
+    document.body.appendChild(textarea);
+    textarea.select();
+    // textarea.setSelectionRange(0, textarea.value.length)
+    var result = document.execCommand('copy')
+    document.body.removeChild(textarea)
+    if (result) {
+        console.log('复制成功');
+        success && success()
+    } else {
+        console.log('复制失败');
+        fail && fail()
+    }
+};
+/**
+ * EaseNum的回调函数
+ * @callback OnEase
+ * @param {number} curNum 当前数字
+ * @param {Function} stopEase 停止缓动的方法
+ */
+/**
+ * 缓动数字（整数）
+ * @param {number} startNum 开始数
+ * @param {number} endNum 结束数
+ * @param {number} time 缓动时间
+ * @param {OnEase} onEase 缓动每步回调
+ * @returns {Function} 停止缓动方法
+ */
+ function EaseNum(startNum, endNum, time, onEase) {
+    // console.log('EaseNum', startNum, endNum, time);
+    let stopfn = ()=>{};
+    const stopEase = () => stopfn();
+    if (time == 0 || startNum == endNum) {
+        onEase(endNum, stopEase);
+    } else {
+        let interval = 50; // 基础变化间隔时间
+        let perNum = (endNum - startNum) / (time / interval); // 单次增加量
+        if (perNum > 0) {
+            if (perNum < 1) {
+                perNum = 1;
+                interval = Math.floor(time / (endNum - startNum));
+            } else {
+                interval = Math.floor(interval * Math.ceil(perNum) / perNum);
+                perNum = Math.ceil(perNum);
+            }
+        }
+        if (perNum < 0) {
+            if (perNum > -1) {
+                perNum = -1;
+                interval = Math.floor(time / (startNum - endNum));
+            } else {
+                interval = Math.floor(interval * Math.floor(perNum) / perNum);
+                perNum = Math.floor(perNum);
+            }
+        }
+        // console.log('perNum', perNum, 'interval', interval);
+        let curNum = startNum;
+        stopfn = DoEveryTime(interval, (dt, stop) => {
+            stopfn = stop;
+            if ((perNum > 0 && (curNum >= endNum)) || (perNum < 0 && (curNum <= endNum))) {
+                curNum = endNum;
+                stop();
+            } else {
+                curNum += perNum;
+            }
+            onEase(curNum, stopEase);
+        })
+    }
+    return stopEase
+}
+/**
+ * DoEveryTime的回调函数
+ * @callback everyTimeCallback
+ * @param {number} dt 实际间隔时间
+ * @param {function} stopContinue 停止继续执行的方法
+ */
+/**
+ * 每time毫秒执行一次fn
+ * @param {number} time 时间间隔，毫秒
+ * @param {everyTimeCallback} fn 需要间隔执行的方法
+ * @returns 返回停止第一次执行的方法
+ */
+function DoEveryTime(time, fn) {
+    let expectedTime = Date.now();
+    let preTime = expectedTime;
+    let startTimer = setTimeout(doIt, time);
+    function doIt() {
+        expectedTime = expectedTime + time;
+        let nowTime = Date.now();
+        let offset = expectedTime - nowTime;      
+        let nextTime = time + offset;
+        if (nextTime < 0) nextTime = 0;
+        let dt = nowTime - preTime;
+        preTime = nowTime
+        let continueTimer = setTimeout(doIt, nextTime);  
+        let stopContinue = ()=>{continueTimer && clearTimeout(continueTimer)};
+        fn(dt, stopContinue);
+    }
+    let stopStart = ()=>{startTimer && clearTimeout(startTimer)}
+    return stopStart
+}
+/**
+ * 设置元素style
+ * @param {object} option 配置
+ * @param {HTMLElement} option.element HTMLElement
+ * @param {object} option.style element.style
+ * @param {Function} [option.onTransitionEnd] transitionend回调
+ * @param {Function} [option.onAnimationEnd] animationend回调
+ */
+function SetElementStyle({element, style, onTransitionEnd, onAnimationEnd}) {
+    const { transition, animation } = style;
+    if(transition !== undefined) element.style.transition = transition;
+    if(animation !== undefined) element.style.animation = animation;
+    setTimeout(()=>{
+        Object.keys(style).forEach(v => {
+            if (v != 'transition' && v != 'animation') {
+                element.style[v] = style[v];
+            }
+        });
+    })
+    if (onTransitionEnd) {
+        element.removeEventListener('transitionend', onTransitionEnd);
+        element.addEventListener('transitionend', onTransitionEnd);
+    }
+    if (onAnimationEnd) {
+        element.removeEventListener('animationend', onAnimationEnd);
+        element.addEventListener('animationend', onAnimationEnd);
+    }
+}
+/**
+ * 获取url中的请求参数
+ * @param {string} url 链接
+ * @returns 返回参数键值对object
+ */
+function GetUrlParams(url){
+    var paramObject = {};
+    var rawParamStr = url.split('?')[1];
+    if (rawParamStr) {
+        var rawKeyValues = rawParamStr.split('&');
+        rawKeyValues.forEach((v,i)=>{
+            var key = v.split('=')[0];
+            var value = v.split('=')[1];
+            paramObject[key] = decodeURIComponent(value);
+        })  
+    } 
+    return paramObject; 
+};
+/**
+ * 加工时间戳
+ * @param {number} timestamp 时间戳
+ * @param {string} type 输出类型，自定义
+ */
+ function ProcessTimestamp(timestamp, type) {
+    let time =  new Date(+timestamp);
+    let yearStr = time.getFullYear();
+    let month = time.getMonth() + 1;
+    let monthStr = month > 9 ? month : '0' + month;
+    let date = time.getDate();
+    let dateStr = date > 9 ? date : '0' + date;
+    let hour = time.getHours();
+    let hourStr = hour > 9 ? hour : '0' + hour;
+    let minute = time.getMinutes();
+    let minuteStr = minute > 9 ? minute : '0' + minute;
+    let second = time.getSeconds();
+    let secondStr = second > 9 ? second : '0' + second;
+    switch (type) {
+        case '1':
+            return `${yearStr}-${monthStr}-${dateStr} ${hourStr}:${minuteStr}:${secondStr}`
+        case '2':
+            return `${yearStr}.${monthStr}.${dateStr} ${hourStr}:${minuteStr}`
+    }
+}
+/**
+ * 加工秒数，输出HH:MM:SS
+ * @param {number} leftSecond 剩余秒数
+ */
+function ProcessleftSecond(leftSecond) {
+	let hour = Math.floor(leftSecond / 3600);
+	let hourStr = hour.toString().length == 1 ? `0${hour}` : `${hour}`;
+	let minute = Math.floor((leftSecond % 3600) / 60);
+	let minuteStr = minute.toString().length == 1 ? `0${minute}` : `${minute}`;
+	let second = Math.ceil(leftSecond - 3600*hour - 60*minute);//不足1秒按1秒计
+	let secondStr = second.toString().length == 1 ? `0${second}` : `${second}`;
+	return `${hourStr}:${minuteStr}:${secondStr}`
+}
+/**
+ * 获取星期索引：0到6对应星期一到星期日
+ * @param {string|number} time 标准日期格式或时间戳
+ */
+function GetDayIndex(time) {
+    if (typeof time == 'string') {
+        time = time.replace(/-/g, '/');
+    }
+    let index = new Date(time).getDay() - 1;
+    if(index == -1) index = 6;
+    return index;
+}
\ No newline at end of file
--- a/src/lib/preload.js
+++ b/src/lib/preload.js
+import { loadSvga } from '@spark/animation'
+import * as FYGE from 'fyge';
+import {Howl, Howler} from 'howler';
+import { RES_PATH } from '../../sparkrc.js'
+export { PreloadAsset }
+/**
+ * 预加载资源（/png|jpg|jpeg|svga|spi|json|mp3|wav/）
+ * @param {string[]} urlList 资源地址列表
+ * @param {number} [batchNum] 每批并行加载的资源个数（一般来说该数字越大整体加载速度越快，但加载前期会更卡顿），默认值10
+ * @param {Function} [onProgress] 加载进度回调，每加载完一个资源回调一次，入参为进度值（0，1]
+ * @returns {Promise} 返回一个只会resolve(loadedData)的promise，loadedData保存了所有预加载好的资源，可通过相对路径索引
+ * @example 
+ * //例
+ * const loadedData = await PreloadAsset(urlList);
+ * const image = loadedData['image/fish.png'];
+ * const svgaData = loadedData['svga/fish.svga'];
+ * const spiData = loadedData['spine/fish.spi'];
+ * const lottieData = loadedData['lottie/fish.json'];
+ * const audio = loadedData['audio/laugh.mp3'];
+ */
+ function PreloadAsset(urlList, batchNum, onProgress) {
+    return new Promise((resolve) => {
+        /** 要加载资源总数 */
+        const totalNum = urlList.length;
+        /** 要加载的资源索引 */
+        let assetIndex = -1;
+        /** 已加载完毕的资源个数 */
+        let loadedNum = 0;
+        /** 存放加载好的数据，用地址索引 */
+        const loadedData = {};
+        let startLoadTime = new Date().getTime();
+        /** 加载逻辑 */
+        const doLoad = async () => {
+            if (loadedNum >= totalNum) {
+                console.log('加载完毕', new Date().getTime())
+                let endLoadTime = new Date().getTime();
+                let loadResTime = endLoadTime - startLoadTime;
+                loadedData['loadTime'] = loadResTime/1000;
+                resolve(loadedData); // 加载完毕
+            } else {
+                assetIndex++;
+                if (assetIndex >= totalNum) return
+                const key = urlList[assetIndex];
+                const url = RES_PATH + urlList[assetIndex];
+                const result = await loadOneAsset(url);
+                if (!result) {
+                    console.warn('加载异常', url);
+                    // Itoast('网络异常，请检查网络状态！');
+                }
+                loadedData[key] = result;
+                loadedNum++;
+                onProgress && onProgress(loadedNum / totalNum);
+                doLoad();
+            }
+        }
+        batchNum = batchNum || 10;
+        for (let index = 0; index < batchNum; index++) {
+            doLoad();
+        }
+    })
+}
+/**
+ * 加载一个资源
+ * @param {string} url 地址
+ */
+async function loadOneAsset(url) {
+    const fileType = url.split('.').pop();
+    switch (true) {
+        case (/png|jpg|jpeg/).test(fileType):
+            return await loadOneImg(url);
+        case (/svga/).test(fileType):
+            return await loadOneSvga(url);
+        case (/spi/).test(fileType):
+            return await loadOneSpi(url);
+        case (/json/).test(fileType):
+            return await loadOneJson(url);
+        case (/mp3|wav/).test(fileType):
+            return await loadOneAudio(url);
+        default:
+            console.warn('非法资源', url);
+            return false;
+    }
+}
+/**
+ * 加载一张图片
+ * @param {string} url 地址
+ */
+function loadOneImg(url) {
+    return new Promise(resolve => {
+        const img = new Image();
+        img.onload = () => resolve(img);
+        img.onerror = err => {
+            console.warn('load', url, err);
+            resolve(false)
+        };
+        img.crossOrigin = 'Anonymous'
+        img.src = url;
+    })
+}
+/**
+ * 加载一个svga
+ * @param {string} url 地址
+ */
+function loadOneSvga(url) {
+    return new Promise(resolve => {
+        loadSvga(url).then((data) => resolve(data[0])).catch(err => {
+            console.warn('load', url, err);
+            resolve(false)
+        });
+    })
+}
+/**
+ * 加载一个spine
+ * @param {string} url 地址
+ */
+function loadOneSpi(url) {
+    return new Promise(resolve => {
+        FYGE.loadSpine(url, spineData => {
+            resolve(spineData);
+        }, err => {// 404时走不到？
+            console.warn('load', url, err);
+            resolve(false);
+        })
+    })
+}
+/**
+ * 加载一个Json
+ * @param {string} url 地址
+ */
+function loadOneJson(url) {
+    return new Promise(resolve => {
+        FYGE.GlobalLoader.loadJson((result, res) => {
+            // 404时走不到？
+            if (result) {
+                resolve(res);
+            } else {
+                console.warn('load fail', url);
+                resolve(false);
+            }
+        }, url)
+    })
+}
+/**
+ * 加载一个音频
+ * @param {string} url 地址
+ */
+ function loadOneAudio(url) {
+    return new Promise(resolve => {
+        const sound = new Howl({
+            src: url,
+            onload: () => resolve(sound),
+            onloaderror: err => {
+                console.warn('load fail', url, err);
+                resolve(false);
+            },
+        });
+    })
+}
\ No newline at end of file
--- a/src/lib/sendLog.js
+++ b/src/lib/sendLog.js
+export { SendLog };
+/**
+ * 发送埋点
+ * @description
+ * dpm传后两位即可（如'appID.110.1.1'，传'1.1'即可），会自动拼上window.CFG里写入appID和projectId，也可以手动传入appID和projectId
+ * @param {object} data 埋点参数
+ * @param {string} data.type 埋点类型 exposure: 曝光 | click: 点击
+ * @param {string} data.dpm dpm后两位
+ * @param {string} [data.dcm] dcm
+ * @param {string} [data.dom] dom
+ * @param {string} [data.appID] appID
+ * @param {string} [data.projectId] projectId
+ */
+function SendLog(data) {
+    let { type = 'click', dpm, dcm, dom, appID, projectId } = data;
+    const CFG = window.CFG;
+    appID = appID || (CFG ? CFG.appID : '');
+    projectId = projectId || (CFG ? CFG.projectId : '');
+    if (!appID || !projectId || !dpm) {
+        console.warn('未设置appID或projectId或dpm !!!');
+        return;
+    }
+    dpm = `${appID}.110.${dpm}`;
+    dcm = dcm || `202.${projectId}.0.0`;
+    let params = {
+        dpm,
+        dcm,
+        appId: appID,
+    };
+    if(dom) params.dom = dom;
+    if (type === 'click') {
+        jsonp('/log/click', params);
+    } else {
+        jsonp('//embedlog.duiba.com.cn/exposure/standard', params);
+    }
+    // console.log('sendLog', params);
+}
+/**
+ * 发送jsonp请求
+ * @param {string} url 请求地址
+ * @param {{}} params 请求参数
+ */
+function jsonp(url, params = {}) {
+    const src = url + '?' + getParams(params);
+    const scriptEl = document.createElement('script');
+    scriptEl.src = src;
+    scriptEl.onload = function () {
+        document.body.removeChild(scriptEl);
+    };
+    scriptEl.onerror = function () {
+        document.body.removeChild(scriptEl);
+    };
+    document.body.appendChild(scriptEl);
+}
+/**
+ * 对象格式转get请求参数格式，并且加上时间戳
+ * @param {{}} data
+ */
+function getParams(data = {}) {
+    const arr = [];
+    for (let key in data) {
+        arr.push(encodeURIComponent(key) + '=' + encodeURIComponent(data[key]));
+    }
+    //加时间戳防止浏览器取缓存的接口数据
+    arr.push('_=' + Date.now());
+    return arr.join('&');
+}
--- a/src/lib/wrap.js
+++ b/src/lib/wrap.js
+import { Toast } from '@spark/ui'
+import { generateAPI } from '../api/index'
+export { Itoast, BenchAPI, }
+// 自动添加一些wrap.js用到的样式
+(function autoAddStyle() {
+    const ICSS = `
+        .self_toast_item {
+            border-radius: 0.2rem !important;
+            background-color: rgba(0,0,0,0.75) !important;
+        }
+        .self_toast_content {
+            padding: 0.25rem 0.6rem !important;
+        }
+    `
+    const style = document.createElement('style');
+    style.innerHTML = ICSS;
+    document.getElementsByTagName('head')[0].appendChild(style);
+})()
+/**
+ * Toast包装后的：优化了样式，一个toast时间内不会再出其它toast
+ * @param {*} content 内容
+ * @param {number} time 停留时间
+ */
+function Itoast(content, time = 1200) {
+    return Toast(content, time, { itemClass: 'self_toast_item', contentClass: 'self_toast_content', hideOthers: true })
+}
+/**
+ * 替补API
+ * @param {{}} options 请求配置
+ * @param {{}} [params] 请求参数
+ * @return {Promise} 请求结果Promise;
+ */
+function BenchAPI(options, params = {}) {
+    const API = generateAPI({ benchName: options });
+    return API.benchName(params);
+}
--- a/src/modal/modal.jsx
+++ b/src/modal/modal.jsx
+import React, { Component } from "react";
+import './modal.less';
+import { observer } from 'mobx-react';
+import modalStore from '../store/modal';
+import { toJS } from 'mobx';
+export const cfg = {
+};
+@observer
+class Modal extends Component {
+    constructor(props) {
+        super(props);
+    }
+    componentDidMount() { }
+    render() {
+        const list = toJS(modalStore.popList);
+        const PopUp = cfg[list[0]];
+        const _div = document.getElementById("root");
+        let _top = window.scrollY;
+        if (_div && PopUp) {
+            _div.style.position = "fixed";
+        } else {
+            _div && (_div.style.position = "static");
+            window.scrollTo(0, _top);
+        }
+        return <section className="modal-hoc-bg" style={{
+            zIndex: !!modalStore.popList.length ? 1000 : -1,
+            display:!!modalStore.popList.length?'block':'none'
+        }}>
+            {PopUp && <PopUp />}
+        </section>;
+    }
+}
+export default Modal;
\ No newline at end of file
--- a/src/modal/modal.less
+++ b/src/modal/modal.less
+.modal-hoc-bg {
+    position: fixed;
+    top: 0;
+    bottom: 0;
+    right: 0;
+    left: 0;
+    background-color: rgba(0, 0, 0, 0.8);
+    z-index: 1000;
+}
\ No newline at end of file
--- a/src/pages/page_index/comp.jsx
+++ b/src/pages/page_index/comp.jsx
+"use strict";
+import React, { Component } from "react";
+import { SceneId } from "@src/constant";
+import { Global } from "@src/global";
+import "./comp.less";
+import Scene_test from "../scene_test/comp";
+import AssetList from "../../assetList.json";
+import { Loading } from "@spark/ui";
+class Page_index extends Component {
+  state = {
+    sceneId: SceneId.MAIN, // 场景id
+    sceneData: null, // 场景参数
+    show: false,
+  };
+  async componentDidMount() {
+    Global.switchScene = this.switchScene;
+    Global.assetData = await Global.PreloadAsset(
+      AssetList.preloadAsset,
+      10,
+      (progress) => {}
+    );
+    // Global.assetData['loadTime']
+    console.log("111", Global.assetData["loadTime"]);
+    // showLoading()
+    setTimeout(() => {
+      this.setState({
+        show: true,
+      });
+    }, Global.assetData["loadTime"]);
+  }
+  /**
+   * 切换场景
+   * @param {number} sceneId 场景id
+   * @param {*} sceneData 场景参数
+   */
+  switchScene = (sceneId, sceneData = null) => {
+    this.setState({ sceneId, sceneData });
+  };
+  render() {
+    const { sceneId, sceneData, show } = this.state;
+    return (
+      <>
+        {show ? <Scene_test sceneData={sceneData} /> : <>{<span>123</span>}</>}
+        {/* {sceneId == SceneId.MAIN && <Scene_test sceneData={sceneData} />} */}
+        {/* {sceneId == SceneId.MAIN && <Scene_test sceneData={sceneData} />} */}
+      </>
+    );
+  }
+}
+export default Page_index;
--- a/src/pages/page_index/comp.less
+++ b/src/pages/page_index/comp.less
--- a/src/pages/scene_test/comp.jsx
+++ b/src/pages/scene_test/comp.jsx
+'use strict';
+import React, { Component } from 'react';
+import { Global } from '@src/global';
+import { SceneId } from '@src/constant';
+import Rule_for_test from "../../components/rule_for_test/comp";
+import './comp.less';
+import AssetList from '../../assetList.json'
+import { Comp_fyge_canvas, createImg, createSvga, createLottie, createSpine } from '@src/components/comp_fyge_canvas/comp';
+class Scene_test extends Component {
+  onStageReady = async (stage) => {
+    Global.assetData = await Global.PreloadAsset(AssetList.preloadAsset, 10, (progress) => {});
+    // console.log('Global.assetData', Global.assetData['loadTime']);
+    stage.addChildren(
+      createSpine({
+        path: 'test/cow_spine.spi', x: 400, y: 600, skinName: '4级', aniName: '开心', autoPlay: true, onCreated: spine => {
+          console.warn('spine11111=', spine);
+        }
+      })
+    )
+  }
+  /**
+   * 播放音频
+   * @param {object} option 
+   */
+  playAudio = ({ path, volume = 1, loop = false }) => {
+    const audio = Global.assetData[path];
+    console.warn('audio', audio);
+    audio.volume(volume);
+    audio.loop(loop);
+    audio.play();
+    return audio
+  }
+  render() {
+    return (
+      <div className="container" >
+        <Comp_fyge_canvas onStageReady={this.onStageReady} />
+        <div className="scroll_view">
+          <div className="for_click" onClick={() => Global.showPop({ popName: Rule_for_test, isClickBlankHide: true })}>弹窗测试</div>
+        </div>
+      </div>
+    );
+  }
+}
+export default Scene_test;
--- a/src/pages/scene_test/comp.less
+++ b/src/pages/scene_test/comp.less
+.container {
+    position: absolute;
+    height: 100%;
+    width: 100%;
+    background-color: gray;
+    .scroll_view {
+        position: absolute;
+        bottom: 0;
+        height: 500px;
+        width: 100%;
+        background-color: rgb(255, 255, 255);
+      }
+      .for_click {
+        position: relative;
+        height: 70px;
+        line-height: 70px;
+        width: 100%;
+        background-color: red;
+        color: white;
+        margin: 10px 0;
+        font-size: 32px;
+        font-weight: bold;
+        text-align: center;
+      }
+}
\ No newline at end of file
--- a/src/res.less
+++ b/src/res.less
+@RES_PATH: '/src/assets/';
+.sparkBg(@value) {
+  background: url("@{RES_PATH}@{value}") no-repeat top left / 100% 100%;
+}
--- a/src/share.js
+++ b/src/share.js
+import { start, Weixin, WeixinMini, NingboBank, updateShare, callShare, showShareGuide } from '@spark/share'
+export {
+    InitWxShare,
+    InitWxMiniShare,
+    UpdateWxShare,
+    InitAppShare,
+    CallAppShare,
+    ShowShareGuide
+}
+/**
+ * 设置分享动态域名链接
+ */
+async function setShareUrl() {
+    const domain = await window.dbdomain?.getDomain().catch(err => console.warn('动态域名err', err));
+    console.warn('动态域名', domain);
+    CFG.shareConfig.url = `${domain}/projectx/${CFG.projectId}/shareLanding.html?appID=${CFG.appID}`
+}
+/**
+ * 微信分享初始化
+ * @param {{}} shareConfig 分享配置
+ */
+function InitWxShare(shareConfig) {
+    return new Promise(async resolve => {
+        await setShareUrl();
+        start([Weixin]).then(() => {
+            updateShare(shareConfig);
+            resolve(true);
+        }).catch(err => {
+            console.warn('分享初始化失败', err);
+            resolve(false);
+        })
+    })
+}
+/**
+ * 微信小程序分享初始化
+ */
+function InitWxMiniShare(shareConfig) {
+    return new Promise(async resolve => {
+        await setShareUrl();
+        start([WeixinMini]).then(() => {
+            updateShare(shareConfig);
+            resolve(true);
+        }).catch(err => {
+            console.warn('分享初始化失败', err);
+            resolve(false);
+        })
+    })
+}
+/** 更新微信分享配置 */
+const UpdateWxShare = updateShare;
+/**分享引导蒙层 */
+const ShowShareGuide = showShareGuide;
+/**
+ * app分享初始化
+ */
+function InitAppShare() {
+    return new Promise(async resolve => {
+        await setShareUrl();
+        start([NingboBank], (way, success, payload) => {
+            resolve(true)
+            console.warn('app分享' + success ? '成功' : '失败')
+        })
+    })
+}
+/** 唤起app分享 */
+const CallAppShare = callShare;
\ No newline at end of file
--- a/src/store/index.js
+++ b/src/store/index.js
+import { makeAutoObservable } from 'mobx';
+import API from '../api/index';
+const store = makeAutoObservable({
+  ruleInfo: '',
+  setRule(ruleInfo) {
+    this.ruleInfo = ruleInfo;
+  },
+  async initRule() {
+    // 模拟获取远程的数据
+    const { data } = await API.getRule();
+    this.setRule(data);
+  },
+});
+export default store;
--- a/src/store/modal.js
+++ b/src/store/modal.js
+import { makeAutoObservable } from 'mobx';
+//此处配置页面的优先级，越大优先级越高
+// PopIndex:11
+const modalIndex = {
+}
+const modalStore = makeAutoObservable({
+  popList: [],
+  pushPop(key) {
+    if (this.popList.length) {
+      let cacheList = this.popList.slice();
+      cacheList.push(key);
+      cacheList = cacheList.sort((a, b) => ((modalIndex[b] ? modalIndex[b] : 10) - (modalIndex[a] ? modalIndex[a] : 10)))
+      this.popList.clear();
+      this.popList.push(...cacheList);
+    } else {
+      this.popList.push(key);
+    }
+  },
+  closePop(key) {
+    if (key) {
+      this.popList.remove(key);
+    } else {
+      this.popList.shift();
+    }
+  }
+});
+export default modalStore;
--- a/yarn.lock
+++ b/yarn.lock