@zfqh/uniapp-x 0.0.0-stage → 0.0.1

package/lib/hooks/useRedirect.js

@@ -0,0 +1,92 @@
+import { onLoad, onPageShow } from '@dcloudio/uni-app';
+import { parseQuery } from '../utils/query';
+import navigate from '../utils/navigate';
+import { inPages } from '../utils/pages';
+import page from '../configs/page';
+import pathConfig from '../configs/path';
+import { IS_WEBVIEW_ENV, TYPES } from '../utils/consts';
+import { pinia } from '../stores/pinia';
+import { useLoginStore } from '../stores/login';
+/** 登录后重定向 */
+export function useRedirect(webview) {
+    const loginStore = useLoginStore(pinia);
+    onLoad((options = {}) => {
+        const { __referrer, __navigate } = options;
+        if (__referrer) {
+            // 由登录拦截器跳转本页面，记录来源
+            pathConfig['referrer'] = decodeURIComponent(__referrer);
+        }
+        else if (__navigate) {
+            // 登录成功，跳回来源页面后，若需要重定向，则跳转
+            navigate(__navigate.startsWith('/') ? __navigate : decodeURIComponent(__navigate), __navigate ? 'navigateTo' : 'redirectTo');
+        }
+    });
+    onPageShow(() => {
+        const routes = getCurrentPages();
+        const current = `/${routes.pop()?.route}`;
+        if (!loginStore.isLogin) {
+            // #ifdef H5
+            // 防止登录后，返回webview页面再次跳转登录页面
+            if (IS_WEBVIEW_ENV) {
+                return;
+            }
+            // #endif
+            // 检测页面是否跳转登录
+            if (inPages(page.needLoginPages, current)) {
+                navigate({ url: '', needLogin: true });
+            }
+            return;
+        }
+        // 禁止跳转
+        if (inPages(page.notRedirectPages, current)) {
+            return;
+        }
+        const url = pathConfig['referrer'];
+        if (url) {
+            pathConfig['referrer'] = '';
+            const isCurrent = url.startsWith(current);
+            if (webview) {
+                // 登录后，跳回的页面是webview页面，则需要重新加载该页面
+                // #ifdef MP
+                if (inPages(page.tabBarPages, current)) {
+                    // tabbar页面无法在原页面刷新，直接 reLaunch 重新打开来源页
+                    uni.reLaunch({
+                        url,
+                    });
+                }
+                else {
+                    // 非tabbar页面，重新打开页面
+                    uni[routes.length >= 2 ? 'redirectTo' : 'reLaunch']({
+                        url,
+                    });
+                }
+                // #endif
+                // #ifndef MP
+                const { accessToken = '' } = loginStore.state;
+                const [, search] = url.split('?');
+                const { url: _url } = parseQuery(search || '');
+                webview.postMessage({
+                    type: TYPES.MESSAGE.LOGIN,
+                    payload: {
+                        accessToken,
+                        referrer: decodeURIComponent(_url),
+                    },
+                });
+                // #endif
+            }
+            else {
+                if (isCurrent) {
+                    const [, __navigate] = url.split('__navigate=');
+                    if (__navigate) {
+                        // 跳回其他页面，则判断参数是否需要重定向
+                        navigate(__navigate.startsWith('/') ? __navigate : decodeURIComponent(__navigate));
+                    }
+                }
+                else {
+                    // 登录后返回其他页面，比如reLaunch到首页，则重新跳转到原页面
+                    navigate(url);
+                }
+            }
+        }
+    });
+}

package/lib/hooks/useReferrer.d.ts

@@ -0,0 +1 @@
+export declare function useReferrer(): import("vue").Ref<string>;

package/lib/hooks/useReferrer.js

@@ -0,0 +1,11 @@
+import { ref } from 'vue';
+import { onLoad } from '@dcloudio/uni-app';
+export function useReferrer() {
+    const referrer = ref('');
+    onLoad((options) => {
+        if (options?.__referrer) {
+            referrer.value = decodeURIComponent(options.__referrer);
+        }
+    });
+    return referrer;
+}

package/lib/hooks/useShare.d.ts

@@ -0,0 +1,12 @@
+import { type MaybeRefOrGetter } from 'vue';
+export interface ShareData {
+    title?: string;
+    path?: string;
+    content?: string;
+    [key: string]: any;
+}
+/** 分享数据 */
+export declare function useShare(shareData?: MaybeRefOrGetter<ShareData>): {
+    mergeShareData: import("vue").ComputedRef<ShareData>;
+    sendShareDataMessage: () => void;
+};

package/lib/hooks/useShare.js

@@ -0,0 +1,49 @@
+import { computed, toValue, watch } from 'vue';
+import { onPageShow, onShareAppMessage, onShareTimeline } from '@dcloudio/uni-app';
+import { queryParams } from '@zfqh/uview-x/utils/function';
+import { IS_WEBVIEW_ENV, TYPES } from '../utils/consts';
+import { postMessage } from '../utils/index';
+/** 分享数据 */
+export function useShare(shareData = {}) {
+    const mergeShareData = computed(() => {
+        const { route = '', options = {} } = getCurrentPages().pop() || {};
+        return {
+            path: `/${route}${queryParams(options)}`,
+            content: '',
+            // #ifdef H5
+            title: document.title,
+            // #endif
+            ...toValue(shareData),
+        };
+    });
+    function sendShareDataMessage() {
+        // #ifdef H5
+        if (IS_WEBVIEW_ENV) {
+            try {
+                postMessage({
+                    type: TYPES.MESSAGE.SHARE_PAGE,
+                    payload: mergeShareData.value,
+                });
+            }
+            catch (e) { }
+        }
+        else {
+            uni.showShareMenu(mergeShareData.value);
+        }
+        // #endif
+    }
+    // #ifdef H5
+    watch(() => toValue(shareData), sendShareDataMessage, { deep: true });
+    onPageShow(() => {
+        sendShareDataMessage();
+    });
+    // #endif
+    // #ifdef MP
+    onShareAppMessage(() => mergeShareData.value);
+    onShareTimeline(() => mergeShareData.value);
+    // #endif
+    return {
+        mergeShareData,
+        sendShareDataMessage,
+    };
+}

package/lib/hooks/useVersion.d.ts

@@ -0,0 +1,6 @@
+export declare function useVersion(): {
+    version: {
+        name: string;
+        code: number;
+    };
+};

package/lib/hooks/useVersion.js

@@ -0,0 +1,21 @@
+import { reactive } from 'vue';
+import ver from '../configs/ver';
+export function useVersion() {
+    const version = reactive({
+        name: ver.name,
+        code: ver.code,
+    });
+    // #ifdef APP-PLUS
+    plus.runtime.getProperty(plus.runtime.appid, (res) => {
+        if (!version.name) {
+            version.name = res.version;
+        }
+        if (!version.code) {
+            version.code = Number(res.versionCode);
+        }
+    });
+    // #endif
+    return {
+        version,
+    };
+}

package/lib/hooks/useWebview.d.ts

@@ -0,0 +1,14 @@
+import { type MaybeRef, type Ref } from 'vue';
+import type { ShareData } from './useShare';
+export interface UseWebviewOptions {
+    /** H5 下承载页根节点，用于向 iframe 发送消息；缺省回退组件实例 $el */
+    root?: MaybeRef<Element | null | undefined>;
+}
+export interface UseWebviewReturn {
+    shareData: Ref<ShareData>;
+    webviewUrl: Ref<string>;
+    onMessage: (e: any) => Promise<void>;
+    postMessage: (data: any) => void;
+}
+/** webview 承载页逻辑 */
+export declare function useWebview(options?: UseWebviewOptions): UseWebviewReturn;

package/lib/hooks/useWebview.js

@@ -0,0 +1,294 @@
+import { computed, getCurrentInstance, nextTick, ref, toValue, watch } from 'vue';
+import { onLoad, onPageShow, onReady, onUnload } from '@dcloudio/uni-app';
+import { queryParams } from '@zfqh/uview-x/utils/function';
+import { getLocale } from '@zfqh/uview-x';
+import SimpleUrl from '../utils/url';
+import { parseQuery, stringifyQuery } from '../utils/query';
+import { PLATFORM_CODE, IS_WEBVIEW_ENV, SYSTEM_INFO, TYPES, LANGUAGE } from '../utils/consts';
+import appConfig from '../configs/app';
+import { requestPermission, openAuthorizeSetting } from '../utils/permission';
+import web from '../configs/web';
+import cdn from '../configs/cdn';
+import link from '../configs/link';
+import pathConfig from '../configs/path';
+import { base64ToPath } from '../utils/file';
+import query from '../utils/query';
+import { pinia } from '../stores/pinia';
+import { useLoginStore } from '../stores/login';
+import { usePageShow } from './usePageShow';
+/** webview 承载页逻辑 */
+export function useWebview(options = {}) {
+    const instance = getCurrentInstance();
+    const loginStore = useLoginStore(pinia);
+    const pageShow = usePageShow();
+    const shareData = ref({});
+    const params = ref({});
+    const webviewUrl = ref('');
+    const changed = ref(true);
+    let initialParams = {};
+    let webView = null;
+    let post = null;
+    let onWindowMessage = null;
+    let isIframe = false;
+    const queryString = computed(() => {
+        const { accessToken, storeId, userId, tenantId, storeName, tenantName, nickName, username } = loginStore.state || {};
+        // 语言取 @zfqh/uview-x 的 getLocale()（storage / 系统语言，始终有值）；
+        // 未创建 i18n 实例时也会带上系统语言，不再依赖实例上的 locale Ref
+        const locale = getLocale();
+        const q = {
+            token: accessToken,
+            storeId,
+            userId,
+            tenantId,
+            storeName,
+            tenantName,
+            nickName,
+            username,
+            app: appConfig.code || appConfig.appId,
+            channel: appConfig.channel,
+            platform: PLATFORM_CODE,
+            safeTop: SYSTEM_INFO.safeAreaInsets.top,
+            safeBottom: SYSTEM_INFO.safeAreaInsets.bottom,
+            locale,
+            xLanguage: LANGUAGE[locale],
+            accelerate: cdn.isAccelerate ? 1 : undefined,
+        };
+        if (query.primary) {
+            if (String(query.primary).startsWith('#')) {
+                query.primary = encodeURIComponent(query.primary);
+            }
+        }
+        return stringifyQuery(q, { encode: false });
+    });
+    watch(queryString, () => {
+        changed.value = 'changed';
+    });
+    function getRootEl() {
+        const provided = toValue(options.root);
+        if (provided) {
+            return provided;
+        }
+        return instance?.proxy?.$el;
+    }
+    async function onMessage(e) {
+        try {
+            const { type, payload } = e.detail.data.pop();
+            switch (type) {
+                case TYPES.MESSAGE.SAVE_IMAGE: {
+                    const { data } = payload;
+                    await requestPermission('storage');
+                    const filePath = await base64ToPath(data);
+                    uni.saveImageToPhotosAlbum({
+                        filePath,
+                        success() {
+                            uni.showToast({
+                                title: '已保存到相册',
+                                position: 'bottom',
+                            });
+                        },
+                    });
+                    break;
+                }
+                case TYPES.MESSAGE.CHNAGE_TITLE: {
+                    const { title } = payload;
+                    uni.setNavigationBarTitle({
+                        title,
+                    });
+                    break;
+                }
+                case TYPES.MESSAGE.SHARE_PAGE: {
+                    if (!payload.path) {
+                        uni.share(payload);
+                    }
+                    else {
+                        const { path, ...shareRest } = payload;
+                        const { route } = getCurrentPages().pop();
+                        const currentParams = { ...params.value };
+                        delete currentParams.url;
+                        shareData.value = {
+                            ...shareRest,
+                            path: `/${route}${queryParams({ url: encodeURIComponent(path), ...currentParams })}`,
+                        };
+                    }
+                    break;
+                }
+                case TYPES.MESSAGE.PERM_LOCATION:
+                case TYPES.MESSAGE.PERM_BLUETOOTH: {
+                    openAuthorizeSetting(payload.name);
+                    break;
+                }
+                case TYPES.MESSAGE.GET_LOCATION:
+                case TYPES.MESSAGE.OPEN_LOCATION: {
+                    const messageType = TYPES.MESSAGE.GET_LOCATION || TYPES.MESSAGE.OPEN_LOCATION;
+                    const success = (data) => {
+                        postMessage({
+                            type: messageType,
+                            payload: {
+                                success: data,
+                            },
+                        });
+                    };
+                    const fail = (data) => {
+                        postMessage({
+                            type: messageType,
+                            payload: {
+                                fail: data,
+                            },
+                        });
+                    };
+                    try {
+                        await requestPermission('location');
+                        uni.getLocation({
+                            ...payload,
+                            success,
+                            fail,
+                        });
+                    }
+                    catch (error) {
+                        fail(error);
+                    }
+                    break;
+                }
+            }
+        }
+        catch (e) { }
+    }
+    function postMessage(data) {
+        try {
+            if (!post) {
+                // #ifdef H5
+                let ele = getRootEl();
+                if (ele?.tagName !== 'IFRAME') {
+                    ele =
+                        ele?.parentNode?.querySelector?.('iframe') || document.querySelector(`iframe[src="${webviewUrl.value}"]`);
+                }
+                webView = ele?.contentWindow;
+                post = (payload) => {
+                    webView?.postMessage({ type: 'WEBVIEW_MESSAGE', data: payload }, '*');
+                };
+                // #endif
+                // #ifdef APP-PLUS
+                webView = instance?.proxy?.$scope?.$getAppWebview()?.children()?.[0];
+                post = (payload) => {
+                    webView?.evalJS(`window.onmessage({ data: { type: 'WEBVIEW_MESSAGE', data: ${JSON.stringify(payload)} } })`);
+                };
+                // #endif
+            }
+            post?.(data);
+        }
+        catch (e) { }
+    }
+    function initUrl() {
+        const currentParams = params.value;
+        if (currentParams.url) {
+            currentParams.url = decodeURIComponent(currentParams.url);
+            if (/^%/.test(currentParams.url)) {
+                currentParams.url = decodeURIComponent(currentParams.url);
+            }
+        }
+        const { type, app: _app, url: _url, ...rest } = currentParams;
+        let url = _url;
+        let title = rest.title;
+        let src = '';
+        if (_app && web[_app] && /^(https?|file):/.test(web[_app])) {
+            const u = new SimpleUrl(web[_app], true);
+            u.set('query', {
+                ...u.query,
+                ...parseQuery(queryString.value),
+                ...rest,
+                _: Date.now(),
+            });
+            u.set('hash', `#${url}`);
+            src = u.toString();
+        }
+        else {
+            if (link && link[type]) {
+                const { url: _linkUrl, title: _title } = link[type];
+                if (_linkUrl) {
+                    url = _linkUrl;
+                }
+                if (_title) {
+                    title = _title;
+                }
+            }
+            if (url && /^(https?|file):/.test(url)) {
+                const u = new SimpleUrl(url, true);
+                u.set('query', { ...u.query, _: Date.now() });
+                src = u.toString();
+            }
+        }
+        if (title) {
+            uni.setNavigationBarTitle({
+                title,
+            });
+        }
+        webviewUrl.value = src;
+    }
+    onLoad((p) => {
+        params.value = {
+            ...params.value,
+            ...p,
+        };
+        initialParams = {
+            ...params.value,
+        };
+    });
+    onPageShow(async () => {
+        if (changed.value !== true) {
+            await nextTick();
+        }
+        if (changed.value === true || (changed.value === 'changed' && !pathConfig['referrer'])) {
+            params.value = {
+                ...initialParams,
+            };
+            initUrl();
+            changed.value = false;
+        }
+    });
+    onReady(() => {
+        // #ifdef H5
+        if (!IS_WEBVIEW_ENV) {
+            onWindowMessage = (e) => {
+                if (pageShow.value) {
+                    try {
+                        if (e.data.type === 'WEBVIEW_APP_MESSAGE') {
+                            onMessage({ detail: { data: [e.data.data] } });
+                        }
+                        else if (e.data.type === 'WEB_INVOKE_APPSERVICE') {
+                            // webview页面自定义iframe，嵌套页面中调用uni.webView[xx]()，必须实现如下功能，否则无效
+                            if (!isIframe) {
+                                const root = getRootEl();
+                                if (root?.tagName === 'IFRAME' || root?.parentNode?.querySelector?.('iframe')) {
+                                    isIframe = true;
+                                }
+                            }
+                            if (isIframe) {
+                                const { name, arg } = e.data.data || {};
+                                if (['navigateTo', 'redirectTo', 'reLaunch', 'switchTab', 'navigateBack'].includes(name)) {
+                                    uni[name](arg);
+                                }
+                            }
+                        }
+                    }
+                    catch (e) { }
+                }
+            };
+            window.addEventListener('message', onWindowMessage);
+        }
+        // #endif
+    });
+    onUnload(() => {
+        // #ifdef H5
+        if (onWindowMessage) {
+            window.removeEventListener('message', onWindowMessage);
+            onWindowMessage = null;
+        }
+        // #endif
+    });
+    return {
+        shareData,
+        webviewUrl,
+        onMessage,
+        postMessage,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,27 @@
+import type { App } from 'vue';
+import toast from './utils/toast';
+import navigate from './utils/navigate';
+import config from './configs';
+import cos from './utils/cos';
+import './utils/uni';
+import './utils/message';
+export * from './hooks';
+export * from './utils';
+export * from './utils/file';
+export * from './utils/storage';
+export * from './utils/pages';
+export * from './utils/consts';
+export * from './utils/request';
+export * from './utils/subscribe';
+export * from './utils/permission';
+export * from './utils/audio';
+export * from './utils/update';
+export * from './stores';
+export { default as query } from './utils/query';
+export { defineConfig, defineEnvConfig } from './configs';
+export { cos, toast, navigate, config };
+declare function install(app: App): void;
+declare const _default: {
+    install: typeof install;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,26 @@
+import toast from './utils/toast';
+import navigate from './utils/navigate';
+import config from './configs';
+import cos from './utils/cos';
+import { installStore } from './stores';
+import './utils/uni';
+import './utils/message';
+export * from './hooks';
+export * from './utils';
+export * from './utils/file';
+export * from './utils/storage';
+export * from './utils/pages';
+export * from './utils/consts';
+export * from './utils/request';
+export * from './utils/subscribe';
+export * from './utils/permission';
+export * from './utils/audio';
+export * from './utils/update';
+export * from './stores';
+export { default as query } from './utils/query';
+export { defineConfig, defineEnvConfig } from './configs';
+export { cos, toast, navigate, config };
+function install(app) {
+    installStore(app);
+}
+export default { install };

package/lib/stores/app.d.ts

@@ -0,0 +1,51 @@
+export interface AppInfo {
+    appId: string;
+    identifier: string;
+    iconUrl: string;
+    name: string;
+    brief: string;
+    configJson: Record<string, any>;
+    perms: any[];
+    appType: number;
+}
+/** 应用详情 */
+export declare const useAppStore: import("pinia").StoreDefinition<"app", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<{
+        appId: string;
+        identifier: string;
+        iconUrl: string;
+        name: string;
+        brief: string;
+        configJson: Record<string, any>;
+        perms: any[];
+        appType: number;
+    }>;
+    setAppInfo: (data?: Partial<AppInfo> | null) => void;
+    getAppInfo: () => Promise<void>;
+}, "state">>, Pick<{
+    state: import("vue").Ref<{
+        appId: string;
+        identifier: string;
+        iconUrl: string;
+        name: string;
+        brief: string;
+        configJson: Record<string, any>;
+        perms: any[];
+        appType: number;
+    }>;
+    setAppInfo: (data?: Partial<AppInfo> | null) => void;
+    getAppInfo: () => Promise<void>;
+}, never>, Pick<{
+    state: import("vue").Ref<{
+        appId: string;
+        identifier: string;
+        iconUrl: string;
+        name: string;
+        brief: string;
+        configJson: Record<string, any>;
+        perms: any[];
+        appType: number;
+    }>;
+    setAppInfo: (data?: Partial<AppInfo> | null) => void;
+    getAppInfo: () => Promise<void>;
+}, "setAppInfo" | "getAppInfo">>;

package/lib/stores/app.js

@@ -0,0 +1,57 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import { getStorageSync, setStorage } from '../utils/storage';
+import { TYPES } from '../utils/consts';
+import { getAppData, getAppByUser } from '../apis/core';
+import appConfig from '../configs/app';
+import { pinia } from './pinia';
+import { useLoginStore } from './login';
+function getDefaultState() {
+    return {
+        appId: '',
+        identifier: '',
+        iconUrl: '',
+        name: '',
+        brief: '',
+        configJson: {},
+        perms: [],
+        appType: 0,
+    };
+}
+function normalizeAppInfo(data) {
+    const info = { ...getDefaultState(), ...(data || {}) };
+    try {
+        if (typeof info.configJson === 'string') {
+            info.configJson = JSON.parse(info.configJson || '{}');
+        }
+    }
+    catch (e) {
+        info.configJson = {};
+    }
+    return info;
+}
+/** 应用详情 */
+export const useAppStore = defineStore('app', () => {
+    const state = ref(normalizeAppInfo(getStorageSync(TYPES.STORAGE.APP)));
+    function setAppInfo(data) {
+        state.value = normalizeAppInfo(data);
+        setStorage(TYPES.STORAGE.APP, state.value);
+    }
+    async function getAppInfo() {
+        try {
+            const appId = appConfig.appId;
+            if (!appId)
+                return;
+            const loginStore = useLoginStore(pinia);
+            const request = loginStore.isLogin ? getAppByUser : getAppData;
+            const { data } = await request({ appId }, { custom: { message: false } });
+            setAppInfo(data);
+        }
+        catch (e) { }
+    }
+    return {
+        state,
+        setAppInfo,
+        getAppInfo,
+    };
+});