@zfqh/uniapp 0.1.1

package/lib/utils/toast.d.ts

@@ -0,0 +1,17 @@
+export declare const loading: (title?: string | UniNamespace.ShowLoadingOptions, options?: UniNamespace.ShowLoadingOptions) => void;
+export declare const message: (title?: string | UniNamespace.ShowToastOptions, options?: UniNamespace.ShowToastOptions) => Promise<void>;
+export declare const close: () => void;
+export declare const hideToast: () => void;
+export declare const hideLoading: () => void;
+declare const toast: {
+    loading: (title?: string | UniNamespace.ShowLoadingOptions, options?: UniNamespace.ShowLoadingOptions) => void;
+    message: (title?: string | UniNamespace.ShowToastOptions, options?: UniNamespace.ShowToastOptions) => Promise<void>;
+    success: (title?: string | UniNamespace.ShowToastOptions, options?: UniNamespace.ShowToastOptions) => Promise<void>;
+    error: (title?: string | UniNamespace.ShowToastOptions, options?: UniNamespace.ShowToastOptions) => Promise<void>;
+    fail: (title?: string | UniNamespace.ShowToastOptions, options?: UniNamespace.ShowToastOptions) => Promise<void>;
+    exception: (title?: string | UniNamespace.ShowToastOptions, options?: UniNamespace.ShowToastOptions) => Promise<void>;
+    close: () => void;
+    hideToast: () => void;
+    hideLoading: () => void;
+};
+export default toast;

package/lib/utils/toast.js

@@ -0,0 +1,66 @@
+import toastConfig from '../configs/toast';
+export const loading = (title = '', options = {}) => {
+    if (typeof title === 'object') {
+        options = title;
+        title = options.title || '';
+    }
+    uni.showLoading(Object.assign({
+        title: title || '',
+    }, options));
+};
+export const message = (title = '', options = {}) => {
+    if (typeof title === 'object') {
+        options = title;
+        title = options.title || '';
+    }
+    options = Object.assign({
+        title: title || '',
+        icon: 'none',
+        duration: 2000,
+    }, options);
+    return new Promise((res) => {
+        if (options.title) {
+            setTimeout(() => {
+                if (toastConfig.custom === true) {
+                    if (toastConfig.show(options) !== false) {
+                        return;
+                    }
+                }
+                uni.showToast(options);
+            });
+            setTimeout(() => {
+                res();
+            }, options.duration || 2000);
+        }
+        else {
+            res();
+        }
+    });
+};
+export const close = () => {
+    if (toastConfig.custom === true) {
+        if (toastConfig.hide() !== false) {
+            return;
+        }
+    }
+    uni.hideToast();
+};
+export const hideToast = close;
+export const hideLoading = () => uni.hideLoading();
+const toast = {
+    loading,
+    message,
+    success: message,
+    error: message,
+    fail: message,
+    exception: message,
+    close,
+    hideToast,
+    hideLoading,
+};
+['success', 'error', 'fail', 'exception'].forEach((icon) => {
+    toast[icon] = (title, options = {}) => {
+        return message(title, { ...options, icon });
+    };
+});
+export default toast;

package/lib/utils/uni.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/uni.js

@@ -0,0 +1,147 @@
+// #ifdef H5
+import { colorGradient } from '@gmcb/uv-ui/libs/function/colorGradient';
+// #endif
+import { app } from '../configs/app';
+import { brand } from '../configs/brand';
+import mp from '../configs/mp';
+import color from '../configs/color';
+import { IS_WEBVIEW_ENV, SYSTEM_INFO } from './consts';
+import { getPage } from './pages';
+import query from './query';
+// #ifndef H5
+uni.webView = uni;
+if (!uni.webView.postMessage) {
+    uni.webView.postMessage = () => { };
+}
+// #endif
+// #ifdef H5
+// H5下没有该方法，做兼容处理
+uni.hideShareMenu = () => { };
+uni.showShareMenu = () => { };
+// 解决Tree Shaking导致程序报错
+const scanCode = uni.scanCode;
+const chooseImage = uni.chooseImage;
+const chooseVideo = uni.chooseVideo;
+const chooseFile = uni.chooseFile;
+const navigateTo = uni.navigateTo;
+const redirectTo = uni.redirectTo;
+const switchTab = uni.switchTab;
+const reLaunch = uni.reLaunch;
+uni.scanCode = scanCode;
+uni.chooseImage = chooseImage;
+uni.chooseVideo = chooseVideo;
+uni.chooseFile = chooseFile;
+uni.navigateTo = navigateTo;
+uni.redirectTo = redirectTo;
+uni.switchTab = switchTab;
+uni.reLaunch = reLaunch;
+// #endif
+const navigateBack = uni.navigateBack;
+const navigateToMiniProgram = uni.navigateToMiniProgram;
+const openEmbeddedMiniProgram = uni.openEmbeddedMiniProgram;
+uni.navigateBack = (options = {}) => {
+    let { delta = 1 } = options;
+    if (delta < 1) {
+        delta = 1;
+    }
+    const pages = getCurrentPages();
+    const length = pages.length;
+    if (IS_WEBVIEW_ENV && length === 1) {
+        // webview内没有上页，则触发原生返回
+        uni.webView?.navigateBack(options);
+    }
+    else if (!IS_WEBVIEW_ENV &&
+        ((length > 1 && delta >= length) || (length === 1 && !getPage('index')?.includes(pages[0].route)))) {
+        // 非首页返回则跳转到首页
+        uni.reLaunch({
+            url: getPage('index'),
+        });
+    }
+    else {
+        navigateBack(options);
+    }
+};
+uni.navigateToMiniProgram = (options) => {
+    // #ifdef MP
+    navigateToMiniProgram({
+        envVersion: mp.envVersion,
+        ...options,
+    });
+    // #endif
+};
+uni.openEmbeddedMiniProgram = (options) => {
+    // #ifdef MP
+    openEmbeddedMiniProgram({
+        envVersion: mp.envVersion,
+        allowFullScreen: true,
+        ...options,
+    });
+    // #endif
+};
+// 应用是否从后台唤起，在App.onShow中建议使用if (uni.showAppFromBackground) { /* do something */ }
+uni.showAppFromBackground = true;
+// 调用API将appShowFromBackground设置为false，防止App.vue非必要的执行onShow
+[
+    // #ifdef MP
+    'previewImage',
+    'openLocation',
+    'chooseLocation',
+    'chooseAddress',
+    'chooseMessageFile',
+    'openSetting',
+    // #endif
+    // #ifndef APP
+    'scanCode',
+    // #endif
+    'chooseImage',
+    'chooseVideo',
+    'chooseFile',
+].forEach((key) => {
+    const func = uni[key];
+    uni[key] = (options = {}) => {
+        uni.showAppFromBackground = false;
+        return func(options);
+    };
+});
+// #ifdef H5
+if (query) {
+    // 给H5添加安全区域，需再url地址参数中添加safeBottom
+    if (Number(query.safeBottom) > 0) {
+        SYSTEM_INFO.safeAreaInsets.bottom = Number(query.safeBottom);
+        const node = document.createElement('style');
+        node.type = 'text/css';
+        node.innerText = `
+    .uv-safe-area-inset-bottom { padding-bottom: ${query.safeBottom}px; }
+  `.trim();
+        document.body.append(node);
+    }
+    // 隐藏子应用tabbar，不传或者为空字符表示显式子应用tabbar
+    if (query.tabbar != null && query.tabbar !== '') {
+        const node = document.createElement('style');
+        node.type = 'text/css';
+        node.innerText = `
+    .uni-tabbar-bottom { display: none }
+  `.trim();
+        document.body.append(node);
+        window.addEventListener('load', () => {
+            document.documentElement.style.setProperty('--window-bottom', '0px');
+        });
+    }
+    // 更新主题色
+    const primary = String(query.primary ? `#${query.primary}`.replace(/^#+/, '#') : '') ||
+        app[query.app]?.primary ||
+        brand[query.brand]?.primary;
+    if (primary) {
+        const colors = colorGradient(primary, '#fff', 10);
+        document.documentElement.style.setProperty('--primary', (color.primary = colors[0]));
+        document.documentElement.style.setProperty('--primary-light', (color.primaryLight = colors[9]));
+        document.documentElement.style.setProperty('--primary-disabled', (color.primaryDisabled = colors[6]));
+        document.documentElement.style.setProperty('--primary-dark', (color.primaryDark = colors[4]));
+    }
+}
+// const resizeCallback = () => {
+//   document.documentElement.style.setProperty('--window-height', `${window.innerHeight}px`);
+// };
+// resizeCallback();
+// window.addEventListener('resize', resizeCallback);
+// #endif

package/lib/utils/update.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 检测更新
+ * @param immediate 是否立即更新，不显示确认框
+ */
+declare function check(immediate?: boolean): Promise<void>;
+declare const _default: {
+    check: typeof check;
+};
+export default _default;

package/lib/utils/update.js

@@ -0,0 +1,376 @@
+import color from '../configs/color';
+import update from '../configs/update';
+import ver from '../configs/ver';
+import app from '../configs/app';
+import { SYSTEM_INFO } from './consts';
+// 防止弹窗多次弹出
+let visibleModal = false;
+function showModal(options) {
+    uni.showModal({
+        title: '更新提示',
+        content: options?.content || '检测到新版本，下载并重启应用？',
+        confirmColor: color.primary,
+        showCancel: options?.showCancel,
+        fail() {
+            visibleModal = false;
+        },
+        success(res) {
+            if (res.confirm) {
+                options?.confirm && options.confirm();
+            }
+            else {
+                visibleModal = false;
+            }
+        },
+    });
+}
+// #ifdef APP
+function appFileDownload(url, restart = true) {
+    let downloaded = false;
+    const showWaiting = plus.nativeUI.showWaiting('下载中...');
+    const downloadTask = uni.downloadFile({
+        url,
+        success(downloadResult) {
+            if (downloadResult.statusCode === 200) {
+                showWaiting.setTitle('安装中...');
+                setTimeout(() => {
+                    plus.runtime.install(downloadResult.tempFilePath, {
+                        force: true,
+                    }, () => {
+                        plus.nativeUI.closeWaiting();
+                        if (restart) {
+                            visibleModal = false;
+                            uni.showModal({
+                                title: '提示',
+                                content: '应用更新完成',
+                                showCancel: false,
+                                confirmText: '重启应用',
+                                confirmColor: color.primary,
+                                success() {
+                                    plus.runtime.restart();
+                                },
+                            });
+                        }
+                    });
+                }, 500);
+            }
+            else {
+                visibleModal = false;
+                plus.nativeUI.alert('更新失败');
+                plus.nativeUI.closeWaiting();
+            }
+        },
+        fail() {
+            visibleModal = false;
+            plus.nativeUI.closeWaiting();
+        },
+    });
+    downloadTask.onProgressUpdate(({ progress }) => {
+        if (!downloaded) {
+            showWaiting.setTitle('下载中...' + progress + '%');
+            if (progress === 100) {
+                downloaded = true;
+            }
+        }
+    });
+}
+function checkAppUpdate(immediate = false) {
+    return new Promise((resolve, reject) => {
+        plus.runtime.getProperty(plus.runtime.appid, async ({ versionCode, version: versionName }) => {
+            try {
+                const { platform, appName, appId, appVersion: appVersionName, appVersionCode } = SYSTEM_INFO;
+                const params = {
+                    appId: app.appId || appId,
+                    appName: app.name || appName,
+                    versionCode: Number(ver.code || versionCode),
+                    versionName: ver.name || versionName,
+                    appVersionCode: Number(appVersionCode),
+                    appVersionName,
+                    platform,
+                };
+                const data = await update.request(params);
+                if (data) {
+                    let url = '';
+                    if (data.hot_update == 1) {
+                        url = data.wgt_url;
+                    }
+                    else {
+                        if (platform === 'android') {
+                            url = data.apk_url;
+                        }
+                        else if (platform === 'ios') {
+                            url = data.ipa_url;
+                        }
+                    }
+                    if (url) {
+                        resolve();
+                        if (!visibleModal) {
+                            visibleModal = true;
+                            if (data.hot_update == 1) {
+                                // 热更新
+                                if (immediate) {
+                                    appFileDownload(url);
+                                }
+                                else {
+                                    showModal({
+                                        showCancel: !data.force_update,
+                                        confirm() {
+                                            appFileDownload(url);
+                                        },
+                                    });
+                                }
+                            }
+                            else {
+                                // 整包更新
+                                if (params.platform == 'android') {
+                                    if (immediate) {
+                                        if (data.external_install) {
+                                            plus.runtime.openURL(url);
+                                        }
+                                        else {
+                                            appFileDownload(url, false);
+                                        }
+                                    }
+                                    else {
+                                        showModal({
+                                            showCancel: !data.force_update,
+                                            confirm() {
+                                                if (data.external_install) {
+                                                    plus.runtime.openURL(url);
+                                                }
+                                                else {
+                                                    appFileDownload(url, false);
+                                                }
+                                            },
+                                        });
+                                    }
+                                }
+                                else if (params.platform == 'ios') {
+                                    showModal({
+                                        content: '检测到新版本，前往应用市场更新？',
+                                        confirm() {
+                                            plus.runtime.openURL(url);
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        reject();
+                    }
+                }
+                else {
+                    reject();
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    });
+}
+// #endif
+// #ifdef H5
+function fileDownload(url, restart = true) {
+    const ipcRenderer = window['electron'].ipcRenderer;
+    ipcRenderer.send('update', url);
+    function updateDownload() {
+        uni.showLoading({
+            title: '下载中...',
+            mask: true,
+        });
+    }
+    function uploadProgress(e, progress) {
+        uni.showLoading({
+            title: `下载中...${progress}%`,
+            mask: true,
+        });
+    }
+    function updateSuccess() {
+        if (restart) {
+            uni.showModal({
+                title: '提示',
+                content: '应用更新完成',
+                showCancel: false,
+                confirmText: '重启应用',
+                confirmColor: color.primary,
+                success() {
+                    ipcRenderer.send('relaunch');
+                },
+            });
+        }
+    }
+    function updateFail() {
+        setTimeout(() => {
+            uni.showToast({
+                title: '更新失败',
+                icon: 'error',
+                duration: 2000,
+            });
+        }, 300);
+    }
+    function updateComplete() {
+        visibleModal = false;
+        uni.hideLoading();
+        ipcRenderer.removeListener('update-download', updateDownload);
+        ipcRenderer.removeListener('update-progress', uploadProgress);
+        ipcRenderer.removeListener('update-success', updateSuccess);
+        ipcRenderer.removeListener('update-fail', updateFail);
+    }
+    ipcRenderer.on('update-download', updateDownload);
+    ipcRenderer.on('update-progress', uploadProgress);
+    ipcRenderer.on('update-success', updateSuccess);
+    ipcRenderer.on('update-fail', updateFail);
+    ipcRenderer.once('update-complete', updateComplete);
+}
+async function checkUpdate(immediate = false) {
+    return new Promise((resolve, reject) => {
+        const { platform, appName, appId, appVersion: versionName, versionCode } = SYSTEM_INFO;
+        const params = {
+            appId: app.appId || appId,
+            appName: app.name || appName,
+            versionCode: Number(ver.code || versionCode),
+            versionName: ver.name || versionName,
+            appVersionCode: Number(window['versionCode'] || versionCode),
+            appVersionName: window['versionName'] || versionName,
+            platform: window['platform'] || platform,
+        };
+        update
+            .request(params)
+            .then((data) => {
+            if (data) {
+                let url = '';
+                if (data.hot_update == 1) {
+                    url = data.zip_url;
+                }
+                else {
+                    if (params.platform === 'windows') {
+                        url = data.exe_url;
+                    }
+                    else if (params.platform === 'macos') {
+                        url = data.dmg_url;
+                    }
+                }
+                if (url) {
+                    resolve();
+                    if (!visibleModal) {
+                        visibleModal = true;
+                        if (data.hot_update == 1) {
+                            // 热更新
+                            if (immediate) {
+                                fileDownload(url);
+                            }
+                            else {
+                                showModal({
+                                    showCancel: !data.force_update,
+                                    confirm() {
+                                        fileDownload(url);
+                                    },
+                                });
+                            }
+                        }
+                        else {
+                            // 整包更新
+                            if (immediate) {
+                                fileDownload(url, false);
+                            }
+                            else {
+                                showModal({
+                                    showCancel: !data.force_update,
+                                    confirm() {
+                                        fileDownload(url, false);
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    reject();
+                }
+            }
+            else {
+                reject();
+            }
+        })
+            .catch((e) => {
+            reject(e);
+        });
+    });
+}
+// #endif
+// #ifdef MP
+function mpDownload(updateManager) {
+    uni.showLoading({ title: '更新中...' });
+    updateManager.onUpdateReady(() => {
+        uni.hideLoading();
+        setTimeout(() => {
+            visibleModal = false;
+            updateManager.applyUpdate();
+        }, 300);
+    });
+    updateManager.onUpdateFailed(() => {
+        visibleModal = false;
+        uni.hideLoading();
+        uni.showModal({
+            title: '更新失败',
+            content: `请您删除当前小程序，并搜索“${app.name || SYSTEM_INFO.appName}”重新打开应用`,
+            confirmColor: color.primary,
+        });
+    });
+}
+function checkMpUpdate(immediate = false) {
+    return new Promise((resolve, reject) => {
+        if (uni.canIUse('getUpdateManager')) {
+            const updateManager = uni.getUpdateManager();
+            updateManager.onCheckForUpdate((e) => {
+                if (e.hasUpdate) {
+                    visibleModal = true;
+                    resolve();
+                    if (immediate) {
+                        mpDownload(updateManager);
+                    }
+                    else {
+                        showModal({
+                            confirm() {
+                                mpDownload(updateManager);
+                            },
+                        });
+                    }
+                }
+                else {
+                    reject();
+                }
+            });
+        }
+        else {
+            reject();
+        }
+    });
+}
+// #endif
+/**
+ * 检测更新
+ * @param immediate 是否立即更新，不显示确认框
+ */
+function check(immediate = false) {
+    let res = Promise.resolve();
+    if (!visibleModal) {
+        // #ifdef H5
+        if (typeof window['electron'] === 'object') {
+            res = checkUpdate(immediate);
+        }
+        // #endif
+        // #ifdef APP
+        res = checkAppUpdate(immediate);
+        // #endif
+        // #ifdef MP
+        res = checkMpUpdate(immediate);
+        // #endif
+    }
+    return res;
+}
+export default {
+    check,
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@zfqh/uniapp",
+  "version": "0.1.1",
+  "description": "uniapp公共模块",
+  "author": "yinjiazeng@163.com",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "homepage": "https://git.keeprisk.cn/zfqh/front-end/tree/master/packages/uniapp-zfqh",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "tsc": "vue-tsc",
+    "tsc:dev": "vue-tsc --watch",
+    "docs:dev": "vitepress dev . --config .vitepress/config.mts",
+    "docs:build": "vitepress build . --config .vitepress/config.mts"
+  },
+  "keywords": [
+    "uniapp"
+  ],
+  "files": [
+    "docs",
+    "lib",
+    "types",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@gmcb/uv-ui": "0.3.1",
+    "@tencentcloud/chat-uikit-engine": "^2.3.2",
+    "@tencentcloud/tui-core": "^2.3.2",
+    "crypto-js": "^4.2.0",
+    "html2canvas": "^1.4.1",
+    "qs": "^6.13.0",
+    "trtc-wx-sdk": "^1.1.12",
+    "url-parse": "^1.5.10",
+    "vue": "3.4.21",
+    "vue-i18n": "9.1.9",
+    "vuex": "4.1.0"
+  },
+  "devDependencies": {
+    "@dcloudio/types": "^3.4.19",
+    "@types/crypto-js": "^4.2.2",
+    "@types/qs": "^6.9.16",
+    "@types/url-parse": "^1.4.11"
+  },
+  "gitHead": "29f2e4284d8c7e3585410f8800f2b89a39a37cf1"
+}

package/types/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference path="./virtual.d.ts" />
+
+import type { Uni as UniTypes } from '@dcloudio/types';
+import color from '../lib/configs/color';
+
+declare global {
+  interface Uni extends UniTypes {
+    $store: any;
+    $messages: any;
+    $uv: any;
+    webView: any;
+    showAppFromBackground: boolean;
+    getLocationCallback: {
+      [key: string]: (data: any) => void;
+    };
+    openLocationCallback: {
+      [key: string]: (data: any) => void;
+    };
+    requestPermission: (permission: 'location' | 'storage') => Promise<any>;
+  }
+
+  interface Window {
+    __wxjs_environment: string;
+  }
+}

package/types/virtual.d.ts

@@ -0,0 +1 @@
+declare module 'virtual:*';