@zfqh/uniapp 0.1.1

package/lib/mixins/debounce.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    methods: {
+        debounce(...args: any[]): void;
+    };
+};
+export default _default;

package/lib/mixins/debounce.js

@@ -0,0 +1,11 @@
+import Debounce from '../utils/debounce';
+export default {
+    methods: {
+        debounce(...args) {
+            if (!this._debounce) {
+                this._debounce = new Debounce();
+            }
+            this._debounce.exec(...args);
+        },
+    },
+};

package/lib/mixins/deep.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    options: {
+        styleIsolation: string;
+    };
+};
+export default _default;

package/lib/mixins/deep.js

@@ -0,0 +1,8 @@
+export default {
+    // #ifdef MP
+    options: {
+        // 取消样式隔离，可以通过::v-deep 修改子组件样式
+        styleIsolation: 'shared',
+    },
+    // #endif
+};

package/lib/mixins/index.d.ts

@@ -0,0 +1,8 @@
+export { default as app } from './app';
+export { default as badge } from './badge';
+export { default as deep } from './deep';
+export { default as login } from './login';
+export { default as redirect } from './redirect';
+export { default as share } from './share';
+export { default as webview } from './webview';
+export { default as model } from './model';

package/lib/mixins/index.js

@@ -0,0 +1,8 @@
+export { default as app } from './app';
+export { default as badge } from './badge';
+export { default as deep } from './deep';
+export { default as login } from './login';
+export { default as redirect } from './redirect';
+export { default as share } from './share';
+export { default as webview } from './webview';
+export { default as model } from './model';

package/lib/mixins/login.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    onShow(): void;
+};
+export default _default;

package/lib/mixins/login.js

@@ -0,0 +1,25 @@
+import page from '../configs/page';
+import { inPages } from '../utils/pages';
+import navigate from '../utils/navigate';
+// #ifdef H5
+import { IS_WEBVIEW_ENV } from '../utils/consts';
+// #endif
+export default {
+    onShow() {
+        if (this.$options.mpType === 'app') {
+            return;
+        }
+        if (uni.showAppFromBackground) {
+            // #ifdef H5
+            // 防止登录后，返回webview页面再次跳转登录页面
+            if (IS_WEBVIEW_ENV && this.$store.state.login?.info?.token == null) {
+                return;
+            }
+            // #endif
+            const { route } = getCurrentPages().pop() || {};
+            if (!this.$store.getters.isLogin && !!route && inPages(page.needLoginPages, `/${route}`)) {
+                navigate({ url: '', needLogin: true });
+            }
+        }
+    },
+};

package/lib/mixins/model.d.ts

@@ -0,0 +1,22 @@
+declare const _default: (prop: {
+    type: any;
+    default: any;
+}) => {
+    props: {
+        value: {
+            type: any;
+            default: any;
+        };
+        modelValue: {
+            type: any;
+            default: any;
+        };
+    };
+    computed: {
+        value(): any;
+    };
+    methods: {
+        updateModel(value: any): void;
+    };
+};
+export default _default;

package/lib/mixins/model.js

@@ -0,0 +1,29 @@
+export default (prop) => {
+    return {
+        props: {
+            // #ifndef VUE3
+            value: prop,
+            // #endif
+            // #ifdef VUE3
+            modelValue: prop,
+            // #endif
+        },
+        // #ifdef VUE3
+        computed: {
+            value() {
+                return this.modelValue;
+            },
+        },
+        // #endif
+        methods: {
+            updateModel(value) {
+                // #ifndef VUE3
+                this.$emit('input', value);
+                // #endif
+                // #ifdef VUE3
+                this.$emit('update:modelValue', value);
+                // #endif
+            },
+        },
+    };
+};

package/lib/mixins/redirect.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    onLoad({ __referrer, __navigate }: {
+        __referrer: any;
+        __navigate: any;
+    }): void;
+    onShow(): void;
+};
+export default _default;

package/lib/mixins/redirect.js

@@ -0,0 +1,94 @@
+import { parse } from 'qs';
+import navigate from '../utils/navigate';
+import { TYPES } from '../utils/message';
+import { inPages } from '../utils/pages';
+import page from '../configs/page';
+import path from '../configs/path';
+import { IS_WEBVIEW_ENV } from '../utils/consts';
+export default {
+    onLoad({ __referrer, __navigate }) {
+        if (__referrer) {
+            // 由登录拦截器跳转本页面，记录来源
+            path['referrer'] = decodeURIComponent(__referrer);
+        }
+        else if (__navigate) {
+            // 登录成功，跳回来源页面后，若需要重定向，则跳转
+            navigate(__navigate.startsWith('/') ? __navigate : decodeURIComponent(__navigate), __navigate ? 'navigateTo' : 'redirectTo');
+        }
+    },
+    onShow() {
+        // App.vue不执行
+        if (this.$options.mpType === 'app') {
+            return;
+        }
+        const routes = getCurrentPages();
+        const current = `/${routes.pop()?.route}`;
+        if (!this.$store.getters.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 = path['referrer'];
+        if (url) {
+            path['referrer'] = '';
+            const isCurrent = url.startsWith(current);
+            if (this.webview) {
+                // 需要设置为false，否则webview.ts onShow也会执行
+                this.changed = false;
+                // 登录后，跳回的页面是webview页面，则需要重新加载该页面
+                // #ifdef MP
+                if (inPages(page.tabBarPages, current)) {
+                    // tabbar页面刷新页面
+                    const [, path] = url.split('?');
+                    const { url: _url } = parse(path, { decoder: (str) => str });
+                    this.params.url = _url;
+                    this.initUrl();
+                }
+                else {
+                    // 非tabbar页面，重新打开页面
+                    uni[routes.length >= 2 ? 'redirectTo' : 'reLaunch']({
+                        url,
+                    });
+                }
+                // #endif
+                // #ifndef MP
+                const { token = '' } = this.loginInfo;
+                const [, path] = url.split('?');
+                const { url: _url } = parse(path, { decoder: (str) => str });
+                this.postMessage({
+                    type: TYPES.LOGIN,
+                    payload: {
+                        token,
+                        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/mixins/share.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    computed: {
+        mergeShareData(): any;
+    };
+    watch: {
+        shareData(): void;
+    };
+    methods: {
+        sendShareDataMessage(): void;
+    };
+    onShow(): void;
+    onShareAppMessage(): any;
+    onShareTimeline(): any;
+};
+export default _default;

package/lib/mixins/share.js

@@ -0,0 +1,55 @@
+import { TYPES } from '../utils/message';
+import { postMessage } from '../utils/index';
+import { IS_WEBVIEW_ENV } from '../utils/consts';
+export default {
+    computed: {
+        mergeShareData() {
+            const { route, options } = getCurrentPages().pop();
+            return {
+                path: `/${route}${uni.$uv.queryParams(options)}`,
+                content: '',
+                // #ifdef H5
+                title: document.title,
+                // #endif
+                ...this.shareData,
+            };
+        },
+    },
+    // #ifdef H5
+    watch: {
+        shareData() {
+            this.sendShareDataMessage();
+        },
+    },
+    methods: {
+        sendShareDataMessage() {
+            if (IS_WEBVIEW_ENV) {
+                try {
+                    postMessage({
+                        type: TYPES.SHARE_PAGE,
+                        payload: this.mergeShareData,
+                    });
+                }
+                catch (e) { }
+            }
+            else {
+                uni.showShareMenu(this.mergeShareData);
+            }
+        },
+    },
+    onShow() {
+        if (this.$options.mpType === 'app') {
+            return;
+        }
+        this.sendShareDataMessage();
+    },
+    // #endif
+    // #ifdef MP
+    onShareAppMessage() {
+        return this.mergeShareData;
+    },
+    onShareTimeline() {
+        return this.mergeShareData;
+    },
+    // #endif
+};

package/lib/mixins/show.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    data(): {
+        pageShow: boolean;
+    };
+    onShow(): void;
+    onHide(): void;
+    onUnload(): void;
+};
+export default _default;

package/lib/mixins/show.js

@@ -0,0 +1,16 @@
+export default {
+    data() {
+        return {
+            pageShow: false,
+        };
+    },
+    onShow() {
+        this.pageShow = true;
+    },
+    onHide() {
+        this.pageShow = false;
+    },
+    onUnload() {
+        this.pageShow = false;
+    },
+};

package/lib/mixins/webview.d.ts

@@ -0,0 +1,26 @@
+declare const _default: {
+    data(): {
+        shareData: {};
+        params: {};
+        url: string;
+        changed: boolean;
+        webview: boolean;
+    };
+    computed: {
+        loginInfo(): any;
+        queryInfo(): any;
+        appInfo(): any;
+        queryString(): string;
+    };
+    watch: {
+        queryString(): void;
+    };
+    methods: {
+        onMessage(e: any): Promise<void>;
+        postMessage(data: any): void;
+        initUrl(): void;
+    };
+    onLoad(params: any): void;
+    onShow(): void;
+};
+export default _default;

package/lib/mixins/webview.js

@@ -0,0 +1,225 @@
+import Url from 'url-parse';
+import { stringify } from 'qs';
+import { TYPES } from '../utils/message';
+import system from '../modules/system';
+import { PLATFORM_CODE, IS_WEBVIEW_ENV } from '../utils/consts';
+import { requestPermission } from '../utils/permit';
+import web from '../configs/web';
+import link from '../configs/link';
+import path from '../configs/path';
+import { base64ToPath } from '../utils/file';
+export default {
+    data() {
+        return {
+            shareData: {},
+            params: {},
+            url: '',
+            changed: true,
+            webview: true,
+        };
+    },
+    computed: {
+        loginInfo() {
+            return this.$store.state.login?.info || {};
+        },
+        queryInfo() {
+            return this.$store.state.query?.info || {};
+        },
+        appInfo() {
+            return this.$store.state.app?.info || {};
+        },
+        queryString() {
+            const { loginInfo, queryInfo, appInfo } = this;
+            const query = {
+                ...queryInfo,
+                token: loginInfo.token || '',
+                brand: appInfo.brand?.code || '',
+                app: appInfo.app?.code || '',
+                platform: PLATFORM_CODE,
+            };
+            if (query.primary) {
+                if (String(query.primary).startsWith('#')) {
+                    query.primary = encodeURIComponent(query.primary);
+                }
+            }
+            return stringify(query, { encode: false });
+        },
+    },
+    watch: {
+        queryString() {
+            this.changed = 'changed';
+        },
+    },
+    methods: {
+        async onMessage(e) {
+            try {
+                const { type, payload } = e.detail.data.pop();
+                switch (type) {
+                    case TYPES.SAVE_IMAGE: {
+                        const { data } = payload;
+                        await requestPermission('storage');
+                        const path = await base64ToPath(data);
+                        uni.saveImageToPhotosAlbum({
+                            filePath: path,
+                            success() {
+                                uni.showToast({
+                                    title: '已保存到相册',
+                                    position: 'bottom',
+                                });
+                            },
+                        });
+                        break;
+                    }
+                    case TYPES.CHNAGE_TITLE: {
+                        const { title } = payload;
+                        uni.setNavigationBarTitle({
+                            title,
+                        });
+                        break;
+                    }
+                    case TYPES.SHARE_PAGE: {
+                        if (!payload.path) {
+                            uni.share(payload);
+                        }
+                        else {
+                            const { path, ...shareRest } = payload;
+                            const { route } = getCurrentPages().pop();
+                            const params = { ...this.params };
+                            delete params.url;
+                            this.shareData = {
+                                ...shareRest,
+                                path: `/${route}${uni.$uv.queryParams({ url: encodeURIComponent(path), ...params })}`,
+                            };
+                        }
+                        break;
+                    }
+                    case TYPES.GET_LOCATION:
+                    case TYPES.OPEN_LOCATION: {
+                        const type = TYPES.GET_LOCATION || TYPES.OPEN_LOCATION;
+                        const success = (e) => {
+                            this.postMessage({
+                                type,
+                                payload: {
+                                    success: e,
+                                },
+                            });
+                        };
+                        const fail = (e) => {
+                            this.postMessage({
+                                type,
+                                payload: {
+                                    fail: e,
+                                },
+                            });
+                        };
+                        try {
+                            await requestPermission('location');
+                            uni.getLocation({
+                                ...payload,
+                                success,
+                                fail,
+                            });
+                        }
+                        catch (e) {
+                            fail(e);
+                        }
+                        break;
+                    }
+                }
+            }
+            catch (e) { }
+        },
+        postMessage(data) {
+            try {
+                if (!this.__webView) {
+                    // #ifdef H5
+                    this.__webView = document.querySelector('iframe')?.contentWindow;
+                    this.__postMessage = (data) => {
+                        this.__webView.postMessage({ type: 'WEBVIEW_MESSAGE', data }, '*');
+                    };
+                    // #endif
+                    // #ifdef APP-PLUS
+                    this.__webView = this.$scope.$getAppWebview().children()[0];
+                    this.__postMessage = (data) => {
+                        this.__webView.evalJS(`window.onmessage({ data: { type: 'WEBVIEW_MESSAGE', data: ${JSON.stringify(data)} } })`);
+                    };
+                    // #endif
+                }
+                this.__postMessage(data);
+            }
+            catch (e) { }
+        },
+        initUrl() {
+            const params = this.params;
+            if (params.url) {
+                params.url = decodeURIComponent(params.url);
+            }
+            const { type, app: _app, url: _url, ...rest } = params;
+            let url = _url;
+            let title = rest.title;
+            let src = '';
+            const queryString = `?${stringify({ _: Date.now(), safeBottom: system.state.info.safeAreaInsets.bottom, ...rest }, { encode: false })}&${this.queryString}`;
+            if (_app && web[_app]) {
+                const sep = /\.html$/i.test(web[_app]) ? '' : '/';
+                src = `${web[_app]}${sep}${queryString}#${url}`;
+            }
+            else {
+                if (link && link[type]) {
+                    const { url: _url, title: _title } = link[type];
+                    if (_url) {
+                        url = _url;
+                    }
+                    if (_title) {
+                        title = _title;
+                    }
+                }
+                if (url && /^https?:/.test(url)) {
+                    const { origin, query, pathname, hash } = new Url(url);
+                    const q = `${queryString}${query.replace(/^\?/, '&')}`;
+                    src = `${origin}${pathname}${q}${hash}`;
+                }
+            }
+            if (title) {
+                uni.setNavigationBarTitle({
+                    title,
+                });
+            }
+            this.url = src;
+        },
+    },
+    onLoad(params) {
+        this.params = {
+            ...this.params,
+            ...params,
+        };
+        this._params = {
+            ...this.params,
+        };
+    },
+    onShow() {
+        if (this.$options.mpType === 'app') {
+            return;
+        }
+        this.$nextTick(() => {
+            if (this.changed === true || (this.changed === 'changed' && !path['referrer'])) {
+                this.params = {
+                    ...this._params,
+                };
+                this.initUrl();
+                this.changed = false;
+            }
+        });
+        // #ifdef H5
+        if (!IS_WEBVIEW_ENV) {
+            window.onmessage = (e) => {
+                try {
+                    if (e.data.type === 'WEBVIEW_APP_MESSAGE') {
+                        this.onMessage({ detail: { data: [e.data.data] } });
+                    }
+                }
+                catch (e) { }
+            };
+        }
+        // #endif
+    },
+};

package/lib/modules/app.d.ts

@@ -0,0 +1,5 @@
+import type { StoreOptions } from 'vuex';
+interface VuexStoreOptions extends StoreOptions<any> {
+}
+declare const store: VuexStoreOptions;
+export default store;

package/lib/modules/app.js

@@ -0,0 +1,19 @@
+import config from '../configs';
+function getDefaultState() {
+    const appInfo = { app: config.app, brand: config.brand };
+    return {
+        info: appInfo,
+    };
+}
+const store = {
+    state: getDefaultState(),
+    mutations: {
+        setAppInfo(state, data) {
+            state.info = {
+                ...state.info,
+                ...data,
+            };
+        },
+    },
+};
+export default store;

package/lib/modules/dict.d.ts

@@ -0,0 +1,8 @@
+import type { StoreOptions } from 'vuex';
+interface VuexStoreOptions extends StoreOptions<any> {
+    request?: (params: {
+        name: string;
+    }) => Promise<any>;
+}
+declare const store: VuexStoreOptions;
+export default store;

package/lib/modules/dict.js

@@ -0,0 +1,43 @@
+function getDefaultState() {
+    return {
+        info: {},
+    };
+}
+const store = {
+    state: getDefaultState(),
+    mutations: {
+        setDictInfo(state, data) {
+            state.info = { ...state.info, ...data };
+        },
+    },
+    actions: {
+        async getDictInfo({ commit, state }, options = {}) {
+            try {
+                const { name, cache } = options;
+                if (name && (!cache || (cache && !state.info[name]))) {
+                    const e = await store.request({ name });
+                    const enums = {};
+                    const values = [];
+                    const labels = [];
+                    const options = e.data.map(({ label, value }) => {
+                        values.push(value);
+                        labels.push(label);
+                        enums[label] = value;
+                        enums[value] = label;
+                        return { label, value };
+                    });
+                    commit('setDictInfo', {
+                        [name]: {
+                            options,
+                            values,
+                            labels,
+                            enums,
+                        },
+                    });
+                }
+            }
+            catch (e) { }
+        },
+    },
+};
+export default store;