@zfqh/uniapp-x 0.0.0-stage → 0.0.2

package/lib/utils/update.js

@@ -0,0 +1,322 @@
+import app from '../configs/app';
+import env from '../configs/env';
+import ver from '../configs/ver';
+import updater from '../configs/updater';
+import { SYSTEM_INFO, IS_WEBVIEW_ENV, TYPES } from './consts';
+import { postMessage } from './index';
+import { pinia } from '../stores/pinia';
+import { useDictStore } from '../stores/dict';
+const { platform, brand } = SYSTEM_INFO;
+let _installMessageHandler = null;
+function getSystemVersionInfo() {
+    return {
+        versionCode: Number(SYSTEM_INFO.appVersionCode || 0),
+        versionName: SYSTEM_INFO.appVersion || '',
+    };
+}
+function toVersionInfo(info) {
+    return {
+        versionCode: Number(info?.code ?? info?.versionCode ?? 0),
+        versionName: info?.name ?? info?.versionName ?? '',
+    };
+}
+function isUniMPSuccess(ret) {
+    return ret?.type === 'success' || Number(ret?.code) === 0;
+}
+/** 主应用 x 端安装包类型：优先显式 fileType，其次 URL 后缀 */
+function resolveFileType(options) {
+    if (options.fileType === 'apk' || options.fileType === 'wgt')
+        return options.fileType;
+    const path = String(options.url || '')
+        .split(/[?#]/)[0]
+        .toLowerCase();
+    if (path.endsWith('.apk'))
+        return 'apk';
+    if (path.endsWith('.wgt'))
+        return 'wgt';
+    return '';
+}
+// #ifdef APP
+function appGetProperty(appId, path) {
+    return new Promise((resolve) => {
+        if (appId === app.appId) {
+            // #ifdef UNI-APP-X
+            resolve(getSystemVersionInfo());
+            // #endif
+            // #ifdef APP-PLUS
+            plus.runtime.getProperty(String(plus.runtime.appid), (res) => resolve(res));
+            // #endif
+        }
+        else {
+            // #ifdef UNI-APP-X
+            if (typeof uni.getUniMPVersion !== 'function') {
+                resolve({});
+                return;
+            }
+            try {
+                uni.getUniMPVersion(appId, (ret) => {
+                    if (isUniMPSuccess(ret) && ret.versionInfo) {
+                        resolve(toVersionInfo(ret.versionInfo));
+                    }
+                    else {
+                        resolve({});
+                    }
+                });
+            }
+            catch {
+                resolve({});
+            }
+            // #endif
+            // #ifdef APP-PLUS
+            plus.io.resolveLocalFileSystemURL(`_doc/${path ? path + '/' : ''}${appId}/manifest.json`, (entry) => {
+                entry.file((file) => {
+                    const reader = new plus.io.FileReader();
+                    reader.onloadend = (e) => {
+                        try {
+                            resolve(JSON.parse(e.target.result));
+                        }
+                        catch {
+                            resolve({});
+                        }
+                    };
+                    reader.readAsText(file);
+                }, () => resolve({}));
+            }, () => resolve({}));
+            // #endif
+        }
+    });
+}
+// #endif
+// #ifdef H5
+function h5GetProperty(appId, path) {
+    return new Promise((resolve) => {
+        if (appId !== app.appId && window.electron) {
+            window.electron.webUtils.getProperty(appId, path, (res) => resolve(res || {}));
+        }
+        else {
+            resolve({ version: ver.name, versionCode: ver.code });
+        }
+    });
+}
+// #endif
+export async function checkVersion(options) {
+    const { appId, versionCode = 0, versionName = '' } = options || {};
+    let info;
+    let latest;
+    let code = 0;
+    let message = '';
+    try {
+        let version = 0;
+        if (options?.versionCode != null) {
+            info = { versionCode, versionName };
+            version = Number(info.versionCode || 0);
+        }
+        else {
+            // #ifdef APP
+            info = (await appGetProperty(appId, options.path));
+            version = Number(info.versionCode || 0);
+            // #endif
+            // #ifdef H5
+            info = (await h5GetProperty(appId, options.path));
+            version = Number(info.versionCode || 0);
+            // #endif
+        }
+        info.versionCode = version;
+        let type = 3;
+        let plat;
+        if (!IS_WEBVIEW_ENV && appId === app.appId) {
+            type = 1;
+            plat = { android: '1', ios: '2', harmony: '3', windows: '4', macos: '5' }[platform];
+        }
+        const res = await updater.request({
+            version,
+            appId,
+            type,
+            platform: plat,
+        });
+        latest = res?.data;
+        if (latest) {
+            // #ifdef APP
+            if (platform === 'android' && appId === app.appId && env.key === 'prod') {
+                const dictStore = useDictStore(pinia);
+                await dictStore.getDictInfo({ name: 'group_relation', cache: true });
+                if (dictStore.state.group_relation?.values?.includes(brand)) {
+                    latest.hotUpdateUrl = '';
+                }
+            }
+            // #endif
+            if (Number(latest.version) > Number(version)) {
+                code = 1;
+            }
+        }
+    }
+    catch (e) {
+        message = e?.message || e?.data?.message || e?.data?.msg || '';
+    }
+    return {
+        code,
+        data: {
+            info,
+            latest,
+        },
+        message,
+    };
+}
+// #ifdef APP
+function appInstall({ appId, url, path, fileType, progress, success, fail }) {
+    let settled = false;
+    const successOnce = () => {
+        if (settled)
+            return;
+        settled = true;
+        success?.();
+    };
+    const failOnce = (message) => {
+        if (settled)
+            return;
+        settled = true;
+        fail?.({ message: message || 'install failed' });
+    };
+    const downloadTask = uni.downloadFile({
+        url,
+        success(res) {
+            if (res.statusCode !== 200)
+                return failOnce('download failed');
+            progress?.(100);
+            setTimeout(() => {
+                if (appId === app.appId) {
+                    // 主应用
+                    // #ifdef UNI-APP-X
+                    const type = resolveFileType({ appId, url, path, fileType });
+                    if (!type) {
+                        failOnce('无法判断安装包类型，请指定 fileType');
+                        return;
+                    }
+                    if (type === 'wgt') {
+                        if (typeof uni.installWgt !== 'function') {
+                            failOnce('当前环境不支持 uni.installWgt');
+                            return;
+                        }
+                        uni.installWgt({
+                            filePath: res.tempFilePath,
+                            success: successOnce,
+                            fail: (e) => failOnce(e?.errMsg || e?.message || 'installWgt failed'),
+                        });
+                    }
+                    else {
+                        if (typeof uni.installApk !== 'function') {
+                            failOnce('当前环境不支持 uni.installApk');
+                            return;
+                        }
+                        uni.installApk({
+                            filePath: res.tempFilePath,
+                            success: successOnce,
+                            fail: (e) => failOnce(e?.errMsg || e?.message || 'installApk failed'),
+                        });
+                    }
+                    // #endif
+                    // #ifdef APP-PLUS
+                    plus.runtime.install(res.tempFilePath, { force: true }, successOnce, ((e) => failOnce(e?.message || String(e))));
+                    // #endif
+                }
+                else {
+                    // uni 小程序子应用
+                    // #ifdef UNI-APP-X
+                    if (typeof uni.installUniMP !== 'function') {
+                        failOnce('当前宿主未注册 uni.installUniMP');
+                        return;
+                    }
+                    uni.installUniMP({ appid: appId, wgtFile: res.tempFilePath }, (ret) => {
+                        if (isUniMPSuccess(ret)) {
+                            successOnce();
+                        }
+                        else {
+                            failOnce(ret?.message || 'installUniMP failed');
+                        }
+                    });
+                    // #endif
+                    // #ifdef APP-PLUS
+                    plus.io.resolveLocalFileSystemURL('_doc/', (docDir) => {
+                        if (path) {
+                            docDir.getDirectory(path, { create: true }, (subDir) => {
+                                plus.zip.decompress(res.tempFilePath, subDir.fullPath, successOnce, ((e) => failOnce(e?.message || String(e))));
+                            }, (e) => failOnce(e?.message || String(e)));
+                        }
+                        else {
+                            plus.zip.decompress(res.tempFilePath, docDir.fullPath, successOnce, ((e) => failOnce(e?.message || String(e))));
+                        }
+                    }, (e) => failOnce(e?.message || String(e)));
+                    // #endif
+                }
+            }, 1000);
+        },
+        fail: (e) => failOnce(e?.errMsg || String(e)),
+    });
+    downloadTask.onProgressUpdate(({ progress: p }) => {
+        const value = Number.isFinite(p) ? Math.min(99, Math.max(0, Math.floor(p))) : 0;
+        progress?.(value);
+    });
+}
+// #endif
+// #ifdef H5
+function h5Install(options) {
+    if (IS_WEBVIEW_ENV) {
+        postMessage({
+            type: TYPES.MESSAGE.APP_INSTALL,
+            payload: {
+                appId: options.appId,
+                url: options.url,
+                path: options.path,
+            },
+        });
+        if (_installMessageHandler) {
+            uni.$off(TYPES.MESSAGE.WEBVIEW_MESSAGE, _installMessageHandler);
+            _installMessageHandler = null;
+        }
+        _installMessageHandler = (e) => {
+            if (e?.type === TYPES.MESSAGE.APP_INSTALL) {
+                if (e.payload?.progress != null) {
+                    options.progress?.(e.payload.progress);
+                }
+                else if (e.payload?.success) {
+                    options.success?.();
+                }
+                else {
+                    options.fail?.({ message: e.payload.message });
+                }
+            }
+        };
+        uni.$on(TYPES.MESSAGE.WEBVIEW_MESSAGE, _installMessageHandler);
+    }
+    else if (window.electron) {
+        window.electron.webUtils.updateApp(options);
+    }
+}
+// #endif
+export function installUpdate(options) {
+    // #ifdef H5
+    h5Install(options);
+    // #endif
+    // #ifdef APP
+    appInstall(options);
+    // #endif
+}
+export function restartApp() {
+    // #ifdef H5
+    if (IS_WEBVIEW_ENV) {
+        postMessage({
+            type: TYPES.MESSAGE.APP_RESTART,
+            payload: {},
+        });
+    }
+    else if (window.electron) {
+        window.electron.ipcRenderer.send('relaunch');
+    }
+    // #endif
+    // #ifdef APP-PLUS
+    plus.runtime.restart();
+    // #endif
+    // #ifdef UNI-APP-X
+    getApp().restart?.();
+    // #endif
+}

package/lib/utils/url.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 轻量 URL 解析/重建，替代 url-parse 在 App 蒸汽模式下的 CJS 互操作问题。
+ * 仅覆盖 webview 场景需要的 origin/path/query/hash 操作。
+ */
+export declare class SimpleUrl {
+    base: string;
+    pathname: string;
+    query: Record<string, any>;
+    hash: string;
+    constructor(input: string, parseQueryFlag?: boolean);
+    set(key: 'query' | 'hash', value: any): this;
+    toString(): string;
+}
+export default SimpleUrl;

package/lib/utils/url.js

@@ -0,0 +1,40 @@
+import { parseQuery, stringifyQuery } from './query';
+/**
+ * 轻量 URL 解析/重建，替代 url-parse 在 App 蒸汽模式下的 CJS 互操作问题。
+ * 仅覆盖 webview 场景需要的 origin/path/query/hash 操作。
+ */
+export class SimpleUrl {
+    base = '';
+    pathname = '';
+    query = {};
+    hash = '';
+    constructor(input, parseQueryFlag = false) {
+        const value = String(input || '');
+        const match = value.match(/^((?:https?|file):\/\/[^/?#]+)([^?#]*)(\?[^#]*)?(#.*)?$/);
+        if (match) {
+            this.base = match[1];
+            this.pathname = match[2] || '';
+            if (parseQueryFlag && match[3]) {
+                this.query = parseQuery(match[3].substring(1));
+            }
+            this.hash = match[4] || '';
+        }
+        else {
+            this.pathname = value;
+        }
+    }
+    set(key, value) {
+        if (key === 'query') {
+            this.query = { ...(value || {}) };
+        }
+        else if (key === 'hash') {
+            this.hash = String(value || '');
+        }
+        return this;
+    }
+    toString() {
+        const queryString = stringifyQuery(this.query);
+        return `${this.base}${this.pathname}${queryString ? `?${queryString}` : ''}${this.hash}`;
+    }
+}
+export default SimpleUrl;

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@zfqh/uniapp-x",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "description": "uniapp x 公共模块",
+  "author": "yinjiazeng@163.com",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "tsc": "vue-tsc",
+    "tsc:dev": "vue-tsc --watch"
+  },
+  "keywords": [
+    "uniapp",
+    "uniapp-x"
+  ],
+  "files": [
+    "lib",
+    "types",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@zfqh/uview-x": "0.0.2",
+    "crypto-es": "^3.1.3",
+    "pinia": "2.1.7",
+    "qs": "^6.13.0",
+    "url-parse": "^1.5.10",
+    "vue": "3.4.21"
+  },
+  "devDependencies": {
+    "@dcloudio/types": "^3.4.19",
+    "@types/qs": "^6.9.16",
+    "@types/url-parse": "^1.4.11"
+  },
+  "gitHead": "abcec16d4c73e83cec02770a553cd89091e35cf3"
+}

package/types/index.d.ts

@@ -0,0 +1,78 @@
+/// <reference path="./virtual.d.ts" />
+
+import type { Uni as UniTypes } from '@dcloudio/types';
+
+declare global {
+  interface UniMPResult {
+    type?: 'success' | 'fail' | string;
+    code?: number | string;
+    message?: string;
+  }
+
+  interface UniMPVersionInfo {
+    name?: string;
+    code?: number | string;
+    versionName?: string;
+    versionCode?: number | string;
+  }
+
+  interface UniMPVersionResult extends UniMPResult {
+    versionInfo?: UniMPVersionInfo;
+  }
+
+  interface Uni extends UniTypes {
+    $uv: any;
+    webView: any;
+    showAppFromBackground: boolean;
+    getLocationCallback: {
+      [key: string]: (data: any) => void;
+    };
+    openLocationCallback: {
+      [key: string]: (data: any) => void;
+    };
+    requestPermission: (permission: 'location' | 'storage') => Promise<any>;
+    /**
+     * uni-app x 安装 APK（官方 API，@dcloudio/types 暂未声明）
+     */
+    installApk?: (options: {
+      filePath: string;
+      success?: (res: any) => void;
+      fail?: (err: any) => void;
+      complete?: (res: any) => void;
+    }) => void;
+    /**
+     * uni-app x 安装 WGT（官方 API，@dcloudio/types 暂未声明）
+     */
+    installWgt?: (options: {
+      filePath: string;
+      ignoreVersion?: boolean;
+      success?: (res: any) => void;
+      fail?: (err: any) => void;
+      complete?: (res: any) => void;
+    }) => void;
+    /**
+     * 宿主注入的 uni 小程序安装方法
+     */
+    installUniMP?: (options: { appid: string; wgtFile: string }, callback?: (result: UniMPResult) => void) => void;
+    /**
+     * 宿主注入的 uni 小程序版本读取方法
+     */
+    getUniMPVersion?: (appid: string, callback: (result: UniMPVersionResult) => void) => void;
+    /**
+     * uni-app x 5.25+ 申请系统权限；@dcloudio/types 暂未声明，构建期补充
+     */
+    requestSystemPermission?: (options: {
+      permissions: string[];
+      success?: (result: { grantedList: string[]; deniedList: string[]; doNotAskAgainList: string[] }) => void;
+      fail?: (result: { errCode: number; errMsg: string }) => void;
+      complete?: (result: any) => void;
+    }) => void;
+  }
+
+  interface Window {
+    __wxjs_environment: string;
+    electron: any;
+    versionName: string;
+    versionCode: number;
+  }
+}

package/types/virtual.d.ts

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