udxcms 1.0.1

package/dist/store/CmsStore.d.ts

@@ -0,0 +1,60 @@
+declare const _default: {
+    state: {
+        countryList: any[];
+        currencyList: any[];
+        commonConf: {};
+        coins: any[];
+        location: {};
+        explorerSets: {};
+        backRouteName: string;
+        exchange: {};
+        exchangeRate: string;
+        exchangeTimer: any;
+        exchangesetCurrent: string;
+        exchangeTime: number;
+        refreshExchangeTime: number;
+        apiCache: {};
+        menuChange: number;
+        menuShow: boolean;
+        backRouteParams: {};
+        routeUrl: string;
+    };
+    getters: {
+        isbridgeChainNeedChange: (state: any, getters: any, rootState: any) => (chainId: any) => boolean;
+    };
+    mutations: {
+        setMenuChange(state: any): void;
+        setMenuShow(state: any, menuShow: any): void;
+        setCountry(state: any, countryList: any): void;
+        setCommonConf(state: any, commonConf: any): void;
+        setCurrencyList(state: any, currencyList: any): void;
+        setExplorerSets(state: any, explorerSets: any): void;
+        setLocation(state: any, location: any): void;
+        setRouteUrl(state: any, routeUrl: any): void;
+        setBackRouteName(state: any, backRouteName: any): void;
+        setBackRouteParams(state: any, backRouteParams: any): void;
+        setExchange(state: any, exchangeObj: any): void;
+        setApiCache(state: any, { type, apiDoc }: {
+            type: any;
+            apiDoc: any;
+        }): void;
+    };
+    actions: {
+        getCurrencyFunc({ state, commit, dispatch }: {
+            state: any;
+            commit: any;
+            dispatch: any;
+        }, currency: any): Promise<unknown>;
+        getCurrency({ state, commit, dispatch }: {
+            state: any;
+            commit: any;
+            dispatch: any;
+        }, currency: any): Promise<unknown>;
+        getCurrencyDataByTime({ state, commit, dispatch }: {
+            state: any;
+            commit: any;
+            dispatch: any;
+        }, currency: any): void;
+    };
+};
+export default _default;

package/dist/store/CmsStore.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @Descripttion:
+ * @version:
+ * @Author:
+ * @Date: 2021-07-30 10:46:1
+ * @LastEditors: Lewis
+ * @LastEditTime: 2022-01-25 11:19:06
+ */
+const common_1 = require("../api/common");
+exports.default = {
+    state: {
+        countryList: [],
+        currencyList: [],
+        commonConf: {}, // common style setConf
+        coins: [],
+        location: {},
+        explorerSets: {}, // explorerSet
+        backRouteName: "",
+        exchange: {},
+        exchangeRate: '',
+        exchangeTimer: null,
+        exchangesetCurrent: '',
+        exchangeTime: 50 * 6 * 1000,
+        refreshExchangeTime: 40 * 6 * 1000,
+        apiCache: {},
+        menuChange: 0,
+        menuShow: false,
+        backRouteParams: {},
+        routeUrl: ''
+    },
+    getters: {
+        isbridgeChainNeedChange: (state, getters, rootState) => (chainId) => {
+            return true;
+            // let walletChainId = rootState.wallet.walletChainId; // 当前钱包链接的id
+            // let walletChainType = getters.getChainType(walletChainId) // 获取类型
+            // let chainType = getters.getChainType(chainId) // 获取类型
+            // return (walletChainType == 'bridgeChain' &&  chainType !== 'primaryChain' &&  chainType !== 'bridgeChain') || walletChainType !== 'bridgeChain'
+        }
+        // symbolIcon: (state) => (symbol) => {
+        // 	return state.coins.find((v) => v.symbol === symbol) || {};
+        // },
+        // symbolMOBI: (state) => {
+        // 	let dividend_obj =
+        // 		state.coins.find((v) => v.token_type === "Dividend") || {};
+        // 	return Object.keys(dividend_obj).length > 0;
+        // },
+    },
+    mutations: {
+        setMenuChange(state) {
+            state.menuChange++;
+        },
+        setMenuShow(state, menuShow) {
+            state.menuShow = menuShow;
+        },
+        setCountry(state, countryList) {
+            state.countryList = Object.assign([], countryList);
+        },
+        setCommonConf(state, commonConf) {
+            state.commonConf = commonConf;
+        },
+        // setCoins(state, coins) {
+        // 	state.coins = coins || [];
+        // },
+        setCurrencyList(state, currencyList) {
+            state.currencyList = currencyList || [];
+        },
+        setExplorerSets(state, explorerSets) {
+            state.explorerSets = explorerSets;
+        },
+        setLocation(state, location) {
+            state.location = location;
+        },
+        setRouteUrl(state, routeUrl) {
+            state.routeUrl = routeUrl;
+        },
+        setBackRouteName(state, backRouteName) {
+            state.backRouteName = backRouteName;
+            sessionStorage.setItem('currentPathSearch', location.search);
+        },
+        setBackRouteParams(state, backRouteParams) {
+            state.backRouteParams = backRouteParams;
+            // sessionStorage.setItem('currentPathSearch', location.search)
+        },
+        setExchange(state, exchangeObj) {
+            // 法币切换后，更新法币价格缓存
+            state.exchange = Object.assign(Object.assign({}, state.exchange), { [exchangeObj.currency]: exchangeObj });
+            state.exchangeRate = exchangeObj.rate;
+            localStorage.setItem('exchange', JSON.stringify(state.exchange));
+        },
+        setApiCache(state, { type, apiDoc }) {
+            state.apiCache = Object.assign(Object.assign({}, state.apiCache), { [type]: apiDoc });
+        },
+    },
+    actions: {
+        getCurrencyFunc({ state, commit, dispatch }, currency) {
+            return new Promise((resolve, reject) => {
+                if (currency == 'USD') {
+                    resolve({ USD: '1' });
+                }
+                else {
+                    (0, common_1.getSignleSymbolPrice)({
+                        fsym: 'USD',
+                        tsyms: currency
+                    }).then(res => {
+                        // console.log('getSignleSymbolPrice', res)
+                        resolve(res);
+                    }).catch(err => {
+                        console.log('err', err);
+                        resolve({});
+                    });
+                }
+            });
+        },
+        getCurrency({ state, commit, dispatch }, currency) {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let currencyObj = state.exchange[currency] || {};
+                if (currencyObj && Object.keys(currencyObj).length) {
+                    let time = currencyObj.time;
+                    let nowTime = +new Date();
+                    if (nowTime - time < state.exchangeTime) {
+                        resolve(state.exchange[currency].rate);
+                        return;
+                    }
+                }
+                let exchange = localStorage.getItem('exchange');
+                let exchangeObj = {};
+                try {
+                    exchangeObj = exchange && JSON.parse(exchange) || {};
+                    if (exchangeObj[currency]) {
+                        let { time, rate } = exchangeObj[currency];
+                        let nowTime = +new Date();
+                        if (nowTime - time < state.exchangeTime) {
+                            commit('setExchange', {
+                                rate: rate,
+                                time,
+                                currency
+                            });
+                            resolve(rate);
+                        }
+                        else {
+                            let resCurrency = (yield dispatch('getCurrencyFunc', currency)) || {};
+                            if (Object.keys(resCurrency).length) {
+                                commit('setExchange', {
+                                    rate: resCurrency[currency],
+                                    time,
+                                    currency
+                                });
+                                resolve(resCurrency[currency]);
+                            }
+                            else {
+                                resolve(1);
+                            }
+                        }
+                    }
+                    else {
+                        let resCurrency = (yield dispatch('getCurrencyFunc', currency)) || {};
+                        console.log('resCurrency', resCurrency);
+                        if (resCurrency && Object.keys(resCurrency).length) {
+                            commit('setExchange', {
+                                currency,
+                                rate: resCurrency[currency],
+                                time: +new Date()
+                            });
+                            resolve(resCurrency[currency]);
+                        }
+                        else {
+                            resolve(1);
+                        }
+                    }
+                }
+                catch (error) {
+                    resolve(1);
+                }
+            }));
+        },
+        getCurrencyDataByTime({ state, commit, dispatch }, currency) {
+            if (!state.exchangeTime || state.exchangesetCurrent != currency) {
+                clearInterval(state.exchangeTime);
+                state.exchangeTime = null;
+                if (state.exchangesetCurrent != currency) {
+                    dispatch('getCurrency', currency);
+                }
+                state.exchangeTime = setInterval(() => {
+                    dispatch('getCurrency', currency);
+                }, state.refreshExchangeTime);
+                state.exchangesetCurrent = currency;
+            }
+        }
+    },
+};

package/dist/store/CmsStoreH5.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    state: {};
+    getters: {};
+    mutations: {
+        setCoins(state: any, coins: any): void;
+        setCount(state: any, data: any): void;
+        readOne(state: any): void;
+        clearCount(state: any): void;
+    };
+    actions: {
+        setUnreadCount(context: any, fn: any): Promise<unknown>;
+        readAll(context: any, fn: any): void;
+    };
+};
+export default _default;

package/dist/store/CmsStoreH5.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @Descripttion:
+ * @version:
+ * @Author:
+ * @Date: 2021-07-30 10:46:1
+ * @LastEditors: Lewis
+ * @LastEditTime: 2021-11-19 12:59:09
+ */
+const common_1 = require("../api/h5/common");
+let COINSLOADING = false;
+exports.default = {
+    state: {
+    // coins: [],
+    },
+    // this.$store.getters['member/location'](type)
+    getters: {
+    // symbolIcon: (state) => (symbol) => {
+    // 	return state.coins.find((v) => v.symbol === symbol) || {};
+    // },
+    // symbolMOBI: (state) => {
+    // 	let dividend_obj =
+    // 		state.coins.find((v) => v.token_type === "Dividend") || {};
+    // 	return Object.keys(dividend_obj).length > 0;
+    // },
+    },
+    mutations: {
+        setCoins(state, coins) {
+            state.coins = coins || [];
+        },
+        setCount(state, data) {
+            state.count = data;
+        },
+        readOne(state) {
+            if (state.count >= 1) {
+                state.count = state.count - 1;
+            }
+        },
+        clearCount(state) {
+            state.count = 0;
+        },
+    },
+    actions: {
+        // getCoins(store) {
+        // 	return new Promise((resolve, reject) => {
+        // 		let coins = store.state.coins || [];
+        // 		if (!coins.length && !COINSLOADING) {
+        // 			COINSLOADING = true;
+        // 			getCoin()
+        // 				.then((res) => {
+        // 					let { data, code } = res;
+        // 					if (code == 200) {
+        // 						store.commit("setCoins", data || []);
+        // 						resolve(data);
+        // 					} else {
+        // 						reject([]);
+        // 					}
+        // 				})
+        // 				.catch((err) => {
+        // 					reject([]);
+        // 				})
+        // 				.finally(() => {
+        // 					COINSLOADING = false;
+        // 				});
+        // 		} else {
+        // 			resolve(coins);
+        // 		}
+        // 	});
+        // },
+        setUnreadCount(context, fn) {
+            return new Promise((resolve, reject) => {
+                (0, common_1.getUnreadCount)().then((res) => {
+                    if (res) {
+                        fn && fn(context.state.count, res.data);
+                        context.commit("setCount", res.data);
+                        resolve(1);
+                    }
+                }, (res) => {
+                    context.commit("clearCount");
+                    reject(0);
+                }).catch(e => e);
+            });
+        },
+        readAll(context, fn) {
+            (0, common_1.readAll)().then((res) => {
+                fn && fn();
+                context.commit("clearCount");
+            }, (res) => {
+                context.commit("clearCount");
+            }).catch(e => e);
+        },
+    },
+};

package/dist/store/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CmsStore } from "./CmsStore.ts";
+export { default as CmsStoreH5 } from "./CmsStoreH5.ts";

package/dist/store/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsStoreH5 = exports.CmsStore = void 0;
+var CmsStore_ts_1 = require("./CmsStore.ts");
+Object.defineProperty(exports, "CmsStore", { enumerable: true, get: function () { return __importDefault(CmsStore_ts_1).default; } });
+var CmsStoreH5_ts_1 = require("./CmsStoreH5.ts");
+Object.defineProperty(exports, "CmsStoreH5", { enumerable: true, get: function () { return __importDefault(CmsStoreH5_ts_1).default; } });

package/dist/utils/EventBus.d.ts

@@ -0,0 +1,6 @@
+export default class EventBus {
+    callbacks: {};
+    cacheNames: any[];
+    $on(name: any, fn: any): void;
+    $emit(name: any, args: any): any;
+}

package/dist/utils/EventBus.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @Author:
+ * @Date: 2020-12-31 10:42:43
+ * @LastEditTime: 2021-12-05 13:28:41
+ * @LastEditors: Lewis
+ * @Description:
+ */
+let Base64 = require('js-base64').Base64;
+class EventBus {
+    constructor() {
+        this.callbacks = {};
+        this.cacheNames = [];
+    }
+    $on(name, fn) {
+        if (name && fn) {
+            // 要加上name在前面是因为fn是 async函数的时候，函数是一个Promise对象，进行base64拿后40位是相同的
+            // 所以前面的name加上以防万一
+            let cacheName = name + Base64.encode(name + fn.toString()).replace(/\s/g, '').slice(-40);
+            //  let cacheName = name + new Date().getTime() + Math.floor(Math.random() * 10);
+            //  if (this.cacheName.includes(cacheName)) return
+            //  else {
+            if (this.cacheNames.includes(cacheName)) {
+                this.callbacks[name] = this.callbacks[name] || [];
+                this.callbacks[name].map(v => {
+                    if (v.cacheName == cacheName) {
+                        v.fn = fn;
+                    }
+                });
+            }
+            else {
+                this.cacheNames.push(cacheName);
+                this.callbacks[name] = this.callbacks[name] || [];
+                this.callbacks[name].push({
+                    fn: fn,
+                    cacheName: cacheName
+                });
+            }
+            // this.cacheName.push(cacheName)
+            //  }
+        }
+    }
+    $emit(name, args) {
+        let res = null;
+        if (this.callbacks[name]) {
+            // this.callbacks[name].forEach(cb => cb(args))
+            this.callbacks[name].forEach(cb => cb.fn && (res = cb.fn(args)));
+        }
+        return res;
+    }
+}
+exports.default = EventBus;

package/dist/utils/Session.d.ts

@@ -0,0 +1,6 @@
+export default class Storage {
+    static set(key: any, value: any): void;
+    static get(key: any): any;
+    static remove(key: any): void;
+    static clear(): void;
+}

package/dist/utils/Session.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @Author: Sneed
+ * @Date: 2020-10-28 17:23:58
+ * @LastEditTime: 2021-09-02 10:54:07
+ * @LastEditors: Lewis
+ * @Description:
+ */
+let Base64 = require("js-base64").Base64;
+class Storage {
+    static set(key, value) {
+        sessionStorage.setItem(key, Base64.encode(JSON.stringify(value)));
+    }
+    static get(key) {
+        try {
+            const value = JSON.parse(Base64.decode(sessionStorage.getItem(key)));
+            if (value === null || value === undefined || value === "") {
+                return null;
+            }
+            return value;
+        }
+        catch (err) {
+            const value = sessionStorage.getItem(key);
+            return value || null;
+        }
+    }
+    static remove(key) {
+        sessionStorage.removeItem(key);
+    }
+    static clear() {
+        sessionStorage.clear();
+    }
+}
+exports.default = Storage;

package/dist/utils/Storage.d.ts

@@ -0,0 +1,6 @@
+export default class Storage {
+    static set(key: any, value: any): void;
+    static get(key: any): any;
+    static remove(key: any): void;
+    static getKey(key: any): any;
+}

package/dist/utils/Storage.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @Author: Sneed
+ * @Date: 2020-10-28 17:23:58
+ * @LastEditTime: 2021-07-24 00:45:38
+ * @LastEditors: Lewis
+ * @Description:
+ */
+const localStorageConstant = __importStar(require("../libs/localStorageConstant"));
+let Base64 = require('js-base64').Base64;
+class Storage {
+    static set(key, value) {
+        let newKey = this.getKey(key);
+        localStorage.setItem(newKey, Base64.encode(JSON.stringify(value)));
+    }
+    static get(key) {
+        try {
+            let newKey = this.getKey(key);
+            const value = JSON.parse(Base64.decode(localStorage.getItem(newKey)));
+            if (value === null || value === undefined || value === "") {
+                return null;
+            }
+            return value;
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    static remove(key) {
+        let newKey = this.getKey(key);
+        localStorage.removeItem(newKey);
+    }
+    static getKey(key) {
+        if (!Reflect.has(localStorageConstant, key)) {
+            console.error("Please set constant");
+        }
+        return localStorageConstant[key];
+    }
+}
+exports.default = Storage;

package/dist/utils/apiEvent.d.ts

@@ -0,0 +1,3 @@
+declare const _default: EventBus;
+export default _default;
+import EventBus from "./EventBus";

package/dist/utils/apiEvent.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const EventBus_1 = __importDefault(require("./EventBus"));
+exports.default = new EventBus_1.default();

package/dist/utils/axiosRetry.d.ts

@@ -0,0 +1,4 @@
+export const retryCount: 1;
+export const retryDelay: 100;
+export function getBaseUrl(retry: any): string;
+export function retryFun(instance: any, error: any): Promise<any>;

package/dist/utils/axiosRetry.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryFun = exports.getBaseUrl = exports.retryDelay = exports.retryCount = void 0;
+exports.retryCount = 1; // 重试次数，现在默认重试一次，后期可以调整
+exports.retryDelay = 100; // 重试延迟时间
+let site_common_api_url = '';
+const getBaseUrl = (retry) => {
+    site_common_api_url = site_common_api_url ? site_common_api_url : (site_config && site_config.site_common_api_url) || "";
+    const baseUrlList = site_common_api_url.split(',');
+    const index = retry >= baseUrlList.length ? baseUrlList.length - 1 : retry;
+    return baseUrlList[index];
+};
+exports.getBaseUrl = getBaseUrl;
+const retryFun = (instance, error) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if ((error === null || error === void 0 ? void 0 : error.code) === 'ECONNABORTED' || ((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes("timeout"))) {
+        var config = error.config;
+        if (!config || !config.retry)
+            return Promise.reject(error);
+        if (site_common_api_url) {
+            const baseUrlList = site_common_api_url.split(',');
+            baseUrlList.push(baseUrlList.shift());
+            site_common_api_url = baseUrlList.join(',');
+        }
+        // __retryCount用来记录当前是第几次发送请求
+        config.__retryCount = config.__retryCount || 0;
+        // 如果当前发送的请求大于等于设置好的请求次数时，不再发送请求，返回最终的错误信息
+        if (config.__retryCount >= config.retry) {
+            return Promise.reject(error);
+        }
+        // 记录请求次数+1
+        config.__retryCount += 1;
+        // 设置请求间隔 在发送下一次请求之前停留一段时间，时间为上方设置好的请求间隔时间
+        var backoff = new Promise(function (resolve) {
+            setTimeout(function () {
+                resolve();
+            }, config.retryDelay || 1);
+        });
+        // 再次发送请求
+        return backoff.then(function () {
+            return instance(config);
+        });
+    }
+    else {
+        return Promise.reject(error);
+    }
+});
+exports.retryFun = retryFun;

package/dist/utils/blockies.d.ts

@@ -0,0 +1,2 @@
+export const __esModule: boolean;
+export function toDataUrl(address: any): any;