@zfqh/uniapp 0.1.1

package/lib/utils/permit.js

@@ -0,0 +1,181 @@
+import color from '../configs/color';
+import { SYSTEM_INFO } from './consts';
+// #ifdef APP
+import permission from './permission';
+// #endif
+const permissionData = {
+    location: {
+        // #ifdef APP
+        id: 'android.permission.ACCESS_FINE_LOCATION',
+        system: '检测到系统未开启定位',
+        // #endif
+        content: '我们需要获取您的定位权限，用于城市定位、地址获取、位置获取，发现附近设备等服务',
+    },
+    storage: {
+        // #ifdef APP
+        id: 'android.permission.WRITE_EXTERNAL_STORAGE',
+        system: '',
+        // #endif
+        content: '我们需要获取您的文件存储权限，用于设置头像、保存图片、上传文件、发布内容等服务',
+    },
+    camera: {
+        // #ifdef APP
+        id: 'android.permission.CAMERA',
+        system: '',
+        // #endif
+        content: '我们需要获取您的相机权限，用于拍摄照片、录制视频、视频通话、扫码识别、发布内容等服务',
+    },
+    record: {
+        // #ifdef APP
+        id: 'android.permission.RECORD_AUDIO',
+        system: '',
+        // #endif
+        content: '我们需要获取您的麦克风权限，用于录制语音、语音通话，发布内容等服务',
+    },
+    bluetooth: {
+        // #ifdef APP
+        id: plus?.android?.importClass('android.os.Build')?.['VERSION']?.['SDK_INT'] >= 31
+            ? ['android.permission.BLUETOOTH_SCAN', 'android.permission.BLUETOOTH_CONNECT']
+            : 'android.permission.BLUETOOTH',
+        system: '检测到系统未开启蓝牙',
+        // #endif
+        content: '我们需要获取您的蓝牙权限，用于数据传输、设备配对、发现附近设备等服务',
+    },
+};
+// #ifdef APP
+const requestAndroidPermission = async (name) => {
+    const data = permissionData[name];
+    let res = null;
+    if (data) {
+        uni.showAppFromBackground = false;
+        setTimeout(() => {
+            // 500毫秒内permission.requestAndroidPermission未响应结果，说明系统弹出授权框，此时在顶部显示授权文案
+            if (res == null) {
+                uni.$emit('requestPermission', data);
+            }
+        }, 500);
+        res = await permission.requestAndroidPermission(data.id);
+        uni.$emit('requestPermission', null);
+    }
+    return res;
+};
+// #endif
+// #ifdef MP
+const requestMpPermission = async (scope) => {
+    return await new Promise((res) => {
+        uni.authorize({
+            scope,
+            success() {
+                res(1);
+            },
+            fail() {
+                res(0);
+            },
+        });
+    });
+};
+// #endif
+export function openAuthorizeSetting(name) {
+    // #ifdef APP
+    if (SYSTEM_INFO.platform == 'ios') {
+        plus.runtime.openURL('app-settings://');
+    }
+    else {
+        const main = plus.android.runtimeMainActivity();
+        const Intent = plus.android.importClass('android.content.Intent');
+        const Settings = plus.android.importClass('android.provider.Settings');
+        let intent = null;
+        if (name === 'location') {
+            intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+        }
+        else if (name === 'bluetooth') {
+            intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS);
+        }
+        if (intent) {
+            main.startActivity(intent);
+        }
+    }
+    // #endif
+    // #ifdef MP
+    uni.openAppAuthorizeSetting();
+    // #endif
+}
+export async function requestPermission(name, system = true) {
+    let result = 1;
+    // #ifdef MP
+    switch (name) {
+        case 'location': {
+            result = await requestMpPermission('scope.userLocation');
+            break;
+        }
+        case 'storage': {
+            result = await requestMpPermission('scope.userLocation');
+            break;
+        }
+        case 'bluetooth': {
+            break;
+        }
+        default: {
+            result = await requestMpPermission(`scope.${name}`);
+        }
+    }
+    // #endif
+    // #ifdef APP
+    if (SYSTEM_INFO.platform === 'android') {
+        result = await requestAndroidPermission(name);
+    }
+    else if (SYSTEM_INFO.platform === 'ios') {
+    }
+    if (system && result > 0) {
+        switch (name) {
+            case 'location': {
+                const enabled = await permission.checkSystemEnableLocation();
+                if (!enabled) {
+                    result = -2;
+                }
+                break;
+            }
+            case 'bluetooth': {
+                const enabled = await permission.checkSystemEnableBluetooth();
+                if (!enabled) {
+                    result = -2;
+                }
+            }
+        }
+    }
+    // #endif
+    if (result <= 0) {
+        const { content, system } = permissionData[name];
+        uni.showModal({
+            title: '提示',
+            content: `${result === -2 ? system : `${content}，检测到应用未开启权限`}，是否开启？`,
+            confirmText: '去开启',
+            cancelText: '取消',
+            confirmColor: color.primary,
+            cancelColor: color.tipsColor,
+            success: (res) => {
+                if (res.confirm) {
+                    try {
+                        // #ifdef MP
+                        uni.openSetting();
+                        // #endif
+                        // #ifdef APP
+                        uni.showAppFromBackground = false;
+                        // app开启权限，系统没有开启
+                        if (result === -2) {
+                            openAuthorizeSetting(name);
+                            // 系统开启权限，app没有开启
+                        }
+                        else {
+                            uni.openAppAuthorizeSetting();
+                        }
+                        // #endif
+                    }
+                    catch (e) { }
+                }
+            },
+        });
+        return Promise.reject(0);
+    }
+    return Promise.resolve(1);
+}

package/lib/utils/query.d.ts

@@ -0,0 +1,13 @@
+interface Query {
+    platform?: string;
+    token?: string;
+    primary?: string;
+    brand?: string;
+    app?: string;
+    safeBottom?: string | number;
+    tabbar?: string | number;
+    [key: string]: any;
+}
+declare const query: Query;
+export declare function parseQuery(search?: string): Query;
+export default query;

package/lib/utils/query.js

@@ -0,0 +1,14 @@
+const query = {};
+export function parseQuery(search = '') {
+    search = decodeURIComponent(search);
+    const q = {};
+    search.split('&').forEach((value) => {
+        const [key, val] = value.split('=');
+        q[key] = val;
+    });
+    return q;
+}
+// #ifdef H5
+Object.assign(query, parseQuery(location.search.substring(1)));
+// #endif
+export default query;

package/lib/utils/request.d.ts

@@ -0,0 +1,8 @@
+export declare function formatURL(url: any, data: any): string;
+export declare function createInterceptors(req: any): void;
+export declare function createRequest(req: any, opts?: {}): {
+    GET: (url: any, data?: {}, options?: {}) => any;
+    DELETE: (url: any, data?: {}, options?: {}) => any;
+    POST: (url: any, data?: {}, options?: {}) => any;
+    PUT: (url: any, data?: {}, options?: {}) => any;
+};

package/lib/utils/request.js

@@ -0,0 +1,126 @@
+import log from '../configs/log';
+import toast from './toast';
+import Throttle from './throttle';
+const throttle = new Throttle();
+export function formatURL(url, data) {
+    let newUrl = '';
+    // 匹配动态参数
+    if (/(\/?:\w+)/.test(url)) {
+        url.split(/(\/?:\w+)/).forEach((path) => {
+            if (/^\/?:/.test(path)) {
+                const index = path.startsWith('/:') ? 2 : 1;
+                const key = path.substr(index);
+                newUrl += data[key] !== undefined ? `${index === 2 ? '/' : ''}${data[key]}` : '';
+                delete data[key];
+            }
+            else {
+                newUrl += path;
+            }
+        });
+    }
+    else {
+        newUrl = url;
+    }
+    return newUrl;
+}
+function responseReject(response) {
+    const { data, status, config } = response;
+    if (status === 401) {
+        const { reLogin, needLogin } = config?.custom || {};
+        if (reLogin !== false && needLogin !== false && uni.$store != null) {
+            throttle.exec(() => {
+                if (uni.$store.state.login?.info?.token != null) {
+                    const { message, msg } = data;
+                    if (message || msg) {
+                        toast.message(message || msg);
+                    }
+                    uni.$store.dispatch('logout');
+                }
+            });
+        }
+    }
+    else {
+        if (config?.custom?.message !== false) {
+            const { message, msg } = data;
+            if (message || msg) {
+                toast.message(message || msg);
+            }
+        }
+    }
+    return Promise.reject(response);
+}
+export function createInterceptors(req) {
+    req.interceptors.request.use((config) => {
+        if (log.request) {
+            console.log(`Request URL：${config.baseURL}${config.url}`);
+            console.log(config);
+        }
+        const header = {};
+        if (uni.$store) {
+            const loginInfo = uni.$store.state.login?.info;
+            const { token } = loginInfo || {};
+            if (token) {
+                header.Authorization = `Bearer ${token}`;
+            }
+        }
+        config.header = {
+            ...header,
+            ...config.header,
+        };
+        return config;
+    });
+    req.interceptors.response.use((response) => {
+        const { data, config } = response;
+        if (log.response) {
+            console.log(`Response URL：${config.baseURL}${config.url}`);
+            console.log(data);
+        }
+        if (data.code != 0) {
+            response.status = data.code;
+            return responseReject(response);
+        }
+        return data;
+    }, (error) => {
+        if (!error?.response) {
+            const { config, data, errMsg, status, statusCode } = error;
+            const code = data?.code || statusCode || status || 404;
+            const msg = data?.message || data?.msg || data?.error || errMsg;
+            error.response = {
+                config,
+                data: {
+                    msg,
+                    code,
+                },
+                status: code,
+            };
+        }
+        if (log.response) {
+            console.log('Response Error：', error.response);
+        }
+        return responseReject(error.response);
+    });
+}
+export function createRequest(req, opts = {}) {
+    const GET = (url, data = {}, options = {}) => {
+        url = formatURL(url, data);
+        return req.get(url, { params: data, ...opts, ...options });
+    };
+    const DELETE = (url, data = {}, options = {}) => {
+        url = formatURL(url, data);
+        return req.delete(url, data, { ...opts, ...options });
+    };
+    const POST = (url, data = {}, options = {}) => {
+        url = formatURL(url, data);
+        return req.post(url, data, { ...opts, ...options });
+    };
+    const PUT = (url, data = {}, options = {}) => {
+        url = formatURL(url, data);
+        return req.put(url, data, { ...opts, ...options });
+    };
+    return {
+        GET,
+        DELETE,
+        POST,
+        PUT,
+    };
+}

package/lib/utils/storage.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 同步获取本地缓存
+ * @param name 键名
+ */
+export declare function getStorageSync(name: string): any;
+/**
+ * 异步获取本地缓存
+ * @param name 键名
+ */
+export declare function getStorage(name: string): Promise<unknown>;
+/**
+ * 同步设置本地缓存
+ * @param name 键名
+ * @param data 值
+ */
+export declare function setStorageSync(name: string, data: any): void;
+/**
+ * 异步设置本地缓存
+ * @param name 键名
+ * @param data 值
+ */
+export declare function setStorage(name: string, data: any): Promise<unknown>;
+/**
+ * 同步删除本地缓存
+ * @param name 键名
+ */
+export declare function removeStorageSync(name: string): void;
+/**
+ * 异步删除本地缓存
+ * @param name 键名
+ */
+export declare function removeStorage(name: string): Promise<unknown>;
+/**
+ * 同步删除全部本地缓存
+ */
+export declare function clearStorageSync(): void;
+/**
+ * 异步删除全部本地缓存
+ */
+export declare function clearStorage(): Promise<void>;
+/**
+ * 设置缓存Key
+ */
+export declare function setStorageKeys<T>(data: T): T;
+export interface StorageKeys {
+    query: string;
+    login: string;
+    user: string;
+    open: string;
+    launch: string;
+    location: string;
+}
+export declare const storageKeys: StorageKeys;

package/lib/utils/storage.js

@@ -0,0 +1,145 @@
+import env from '../configs/env';
+import storage from '../configs/storage';
+const getKey = (name) => {
+    const key = [];
+    if (storage.prefix) {
+        key.push(storage.prefix);
+    }
+    if (env.name !== 'prod') {
+        key.push(env.name);
+    }
+    if (name) {
+        key.push(name);
+    }
+    return key.join('_').toUpperCase();
+};
+/**
+ * 同步获取本地缓存
+ * @param name 键名
+ */
+export function getStorageSync(name) {
+    try {
+        const key = getKey(name);
+        return uni.getStorageSync(key);
+    }
+    catch (e) { }
+}
+/**
+ * 异步获取本地缓存
+ * @param name 键名
+ */
+export function getStorage(name) {
+    const key = getKey(name);
+    return new Promise((res, rej) => {
+        uni.getStorage({
+            key,
+            success(e) {
+                res(e);
+            },
+            fail(e) {
+                rej(e);
+            },
+        });
+    });
+}
+/**
+ * 同步设置本地缓存
+ * @param name 键名
+ * @param data 值
+ */
+export function setStorageSync(name, data) {
+    try {
+        const key = getKey(name);
+        uni.setStorageSync(key, data);
+    }
+    catch (e) { }
+}
+/**
+ * 异步设置本地缓存
+ * @param name 键名
+ * @param data 值
+ */
+export function setStorage(name, data) {
+    const key = getKey(name);
+    return new Promise((res, rej) => {
+        uni.setStorage({
+            key,
+            data,
+            success(e) {
+                res(e);
+            },
+            fail(e) {
+                rej(e);
+            },
+        });
+    });
+}
+/**
+ * 同步删除本地缓存
+ * @param name 键名
+ */
+export function removeStorageSync(name) {
+    try {
+        const key = getKey(name);
+        uni.removeStorageSync(key);
+    }
+    catch (e) { }
+}
+/**
+ * 异步删除本地缓存
+ * @param name 键名
+ */
+export function removeStorage(name) {
+    const key = getKey(name);
+    return new Promise((res, rej) => {
+        uni.removeStorage({
+            key,
+            success(e) {
+                res(e);
+            },
+            fail(e) {
+                rej(e);
+            },
+        });
+    });
+}
+/**
+ * 同步删除全部本地缓存
+ */
+export function clearStorageSync() {
+    try {
+        uni.clearStorageSync();
+    }
+    catch (e) { }
+}
+/**
+ * 异步删除全部本地缓存
+ */
+export function clearStorage() {
+    return new Promise((res, rej) => {
+        try {
+            uni.clearStorage();
+            res();
+        }
+        catch (e) {
+            rej(e);
+        }
+    });
+}
+/**
+ * 设置缓存Key
+ */
+export function setStorageKeys(data) {
+    Object.keys(data).forEach((key) => {
+        data[key] = key;
+    });
+    return data;
+}
+export const storageKeys = setStorageKeys({
+    query: '',
+    login: '',
+    user: '',
+    open: '',
+    launch: '',
+    location: '',
+});

package/lib/utils/subscribe.d.ts

@@ -0,0 +1,7 @@
+type SubscribeCallback = (key: string) => void;
+interface SubscribeTemplate {
+    title: string;
+    id: string;
+}
+export declare function subscribeMessage(data?: string[] | SubscribeTemplate[], acceptCallback?: SubscribeCallback, rejectCallback?: SubscribeCallback): Promise<number>;
+export {};

package/lib/utils/subscribe.js

@@ -0,0 +1,94 @@
+import color from '../configs/color';
+// 订阅消息
+export function subscribeMessage(data = [], acceptCallback, rejectCallback) {
+    const tmplIds = data
+        ?.map((id) => {
+        if (typeof id === 'string') {
+            return id;
+        }
+        return id?.id;
+    })
+        ?.filter((e) => !!e);
+    return new Promise((resolve, reject) => {
+        // #ifdef MP-WEIXIN
+        uni.getSetting({
+            withSubscriptions: true,
+            success(res) {
+                let content = '';
+                let list = [];
+                if (!res.subscriptionsSetting?.mainSwitch) {
+                    content = '消息通知权限已关闭，不开启将无法收到系统推送消息，请前往通知管理勾选“接收通知”开启？';
+                }
+                else {
+                    const settings = res.subscriptionsSetting?.itemSettings;
+                    if (settings) {
+                        list = data?.filter((e) => {
+                            if (e && typeof e === 'object') {
+                                return e['id'] && e['title'] && settings[e['id']] === 'reject';
+                            }
+                            return false;
+                        });
+                        if (list?.length) {
+                            content = `${list.map((e) => `“${e['title']}”`).join('')}权限已关闭，不开启将无法收到系统推送消息，请前往通知管理选择“接收并提醒”开启？`;
+                        }
+                    }
+                }
+                if (content) {
+                    uni.showModal({
+                        content,
+                        confirmColor: color.primary,
+                        confirmText: '去开启',
+                        cancelText: '暂不开启',
+                        success({ confirm }) {
+                            if (confirm) {
+                                uni.openSetting();
+                                if (list?.length) {
+                                    resolve(0);
+                                }
+                                else {
+                                    reject();
+                                }
+                            }
+                            else {
+                                resolve(0);
+                            }
+                        },
+                        fail() {
+                            resolve(0);
+                        },
+                    });
+                }
+                else if (tmplIds?.length) {
+                    uni.requestSubscribeMessage({
+                        tmplIds,
+                        success(e) {
+                            Object.keys(e).forEach((key) => {
+                                const val = e[key];
+                                if (val === 'accept' && typeof acceptCallback === 'function') {
+                                    acceptCallback(key);
+                                }
+                                if (val === 'reject' && typeof rejectCallback === 'function') {
+                                    rejectCallback(key);
+                                }
+                            });
+                            resolve(1);
+                        },
+                        fail() {
+                            resolve(0);
+                        },
+                    });
+                }
+                else {
+                    resolve(0);
+                }
+            },
+            fail() {
+                resolve(0);
+            },
+        });
+        // #endif
+        // #ifndef MP-WEIXIN
+        resolve(0);
+        // #endif
+    });
+}

package/lib/utils/throttle.d.ts

@@ -0,0 +1,2 @@
+export default function Throttle(): void;
+export declare const throttle: any;

package/lib/utils/throttle.js

@@ -0,0 +1,32 @@
+export default function Throttle() {
+    this.throttling = false;
+}
+/**
+ * @function 节流
+ * @param {Function} func 要执行的回调函数
+ * @param {Number} wait 延时的时间
+ * @param {Boolean} immediate 是否立即执行
+ */
+Throttle.prototype.exec = function (func, wait = 500, immediate = true) {
+    if (immediate) {
+        if (!this.throttling) {
+            this.throttling = true;
+            // 如果是立即执行，则在wait毫秒内开始时执行
+            typeof func === 'function' && func();
+            setTimeout(() => {
+                this.throttling = false;
+            }, wait);
+        }
+    }
+    else {
+        if (!this.throttling) {
+            this.throttling = true;
+            // 如果是非立即执行，则在wait毫秒内的结束处执行
+            setTimeout(() => {
+                this.throttling = false;
+                typeof func === 'function' && func();
+            }, wait);
+        }
+    }
+};
+export const throttle = new Throttle();