@zfqh/uniapp-x 0.0.0-stage → 0.0.2

package/lib/stores/dict.d.ts

@@ -0,0 +1,35 @@
+export interface DictOption {
+    label: string;
+    value: any;
+    [key: string]: any;
+}
+export interface DictEntry {
+    options: DictOption[];
+    values: any[];
+    labels: string[];
+    enums: Record<string, any>;
+}
+export type DictInfo = Record<string, DictEntry>;
+/** 字典数据 */
+export declare const useDictStore: import("pinia").StoreDefinition<"dict", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<DictInfo>;
+    setDictInfo: (data: Partial<DictInfo>) => void;
+    getDictInfo: (params?: {
+        name: string;
+        cache?: boolean;
+    }) => Promise<void>;
+}, "state">>, Pick<{
+    state: import("vue").Ref<DictInfo>;
+    setDictInfo: (data: Partial<DictInfo>) => void;
+    getDictInfo: (params?: {
+        name: string;
+        cache?: boolean;
+    }) => Promise<void>;
+}, never>, Pick<{
+    state: import("vue").Ref<DictInfo>;
+    setDictInfo: (data: Partial<DictInfo>) => void;
+    getDictInfo: (params?: {
+        name: string;
+        cache?: boolean;
+    }) => Promise<void>;
+}, "setDictInfo" | "getDictInfo">>;

package/lib/stores/dict.js

@@ -0,0 +1,42 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import { getDictData } from '../apis/core';
+/** 字典数据 */
+export const useDictStore = defineStore('dict', () => {
+    const state = ref({});
+    function setDictInfo(data) {
+        state.value = { ...state.value, ...data };
+    }
+    async function getDictInfo(params = {}) {
+        try {
+            const { name, cache } = params;
+            if (name && (!cache || (cache && !state.value[name]))) {
+                const e = await getDictData({ type: name }, { header: { channel: 3 }, custom: { message: false } });
+                const enums = {};
+                const values = [];
+                const labels = [];
+                const options = e.data.map(({ label, value, ...rest }) => {
+                    values.push(value);
+                    labels.push(label);
+                    enums[label] = value;
+                    enums[value] = label;
+                    return { label, value, ...rest };
+                });
+                setDictInfo({
+                    [name]: {
+                        options,
+                        values,
+                        labels,
+                        enums,
+                    },
+                });
+            }
+        }
+        catch (e) { }
+    }
+    return {
+        state,
+        setDictInfo,
+        getDictInfo,
+    };
+});

package/lib/stores/im.d.ts

@@ -0,0 +1,57 @@
+export interface ImInfo {
+    userId: string;
+    usersig: string;
+    sdkappid: number;
+    isLogin: boolean;
+    isReady: boolean;
+}
+/** IM 状态 */
+export declare const useImStore: import("pinia").StoreDefinition<"im", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<{
+        userId: string;
+        usersig: string;
+        sdkappid: number;
+        isLogin: boolean;
+        isReady: boolean;
+    }>;
+    setImInfo: (data?: Partial<ImInfo> | null) => void;
+    resetState: () => void;
+    waitImLogin: () => Promise<boolean>;
+    waitImReady: () => Promise<boolean>;
+    getImInfo: (params?: {
+        username: string;
+        userType?: number;
+    }) => Promise<void>;
+}, "state">>, Pick<{
+    state: import("vue").Ref<{
+        userId: string;
+        usersig: string;
+        sdkappid: number;
+        isLogin: boolean;
+        isReady: boolean;
+    }>;
+    setImInfo: (data?: Partial<ImInfo> | null) => void;
+    resetState: () => void;
+    waitImLogin: () => Promise<boolean>;
+    waitImReady: () => Promise<boolean>;
+    getImInfo: (params?: {
+        username: string;
+        userType?: number;
+    }) => Promise<void>;
+}, never>, Pick<{
+    state: import("vue").Ref<{
+        userId: string;
+        usersig: string;
+        sdkappid: number;
+        isLogin: boolean;
+        isReady: boolean;
+    }>;
+    setImInfo: (data?: Partial<ImInfo> | null) => void;
+    resetState: () => void;
+    waitImLogin: () => Promise<boolean>;
+    waitImReady: () => Promise<boolean>;
+    getImInfo: (params?: {
+        username: string;
+        userType?: number;
+    }) => Promise<void>;
+}, "resetState" | "setImInfo" | "waitImLogin" | "waitImReady" | "getImInfo">>;

package/lib/stores/im.js

@@ -0,0 +1,102 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import { getImData } from '../apis/core';
+function getDefaultState() {
+    return {
+        userId: '',
+        usersig: '',
+        sdkappid: 0,
+        isLogin: false,
+        isReady: false,
+    };
+}
+function settleWaiters(waiters, value, error) {
+    waiters.forEach(({ resolve, reject }) => {
+        if (value) {
+            resolve(true);
+        }
+        else {
+            reject(error);
+        }
+    });
+}
+/** IM 状态 */
+export const useImStore = defineStore('im', () => {
+    const state = ref(getDefaultState());
+    let loginWaiters = [];
+    let readyWaiters = [];
+    function setImInfo(data) {
+        const next = data || {};
+        if (next.isLogin != null) {
+            settleWaiters(loginWaiters, next.isLogin === true, new Error('IM Login Fail'));
+            loginWaiters = [];
+        }
+        if (next.isReady != null) {
+            settleWaiters(readyWaiters, next.isReady === true, new Error('IM Ready Fail'));
+            readyWaiters = [];
+        }
+        Object.assign(state.value, next);
+    }
+    function resetState() {
+        if (state.value.isLogin === true) {
+            uni.$emit('logoutIm');
+        }
+        state.value = getDefaultState();
+        settleWaiters(loginWaiters, false, new Error('IM Login Reset'));
+        settleWaiters(readyWaiters, false, new Error('IM Ready Reset'));
+        loginWaiters = [];
+        readyWaiters = [];
+    }
+    function waitImLogin() {
+        return new Promise((resolve, reject) => {
+            if (state.value.isLogin === true) {
+                resolve(true);
+            }
+            else {
+                loginWaiters.push({ resolve, reject });
+            }
+        });
+    }
+    function waitImReady() {
+        return new Promise((resolve, reject) => {
+            if (state.value.isReady === true) {
+                resolve(true);
+            }
+            else {
+                readyWaiters.push({ resolve, reject });
+            }
+        });
+    }
+    async function getImInfo(params = {}) {
+        try {
+            const { username, userType = 1 } = params;
+            if (!username)
+                return;
+            const { data } = await getImData({ username, userType });
+            // 防止登录其他账号，IM信息不变，先退出之前账号
+            if (state.value.isLogin === true && state.value.userId !== data.userId) {
+                uni.$emit('logoutIm');
+                setImInfo(getDefaultState());
+                // 加延迟防止新账号登录不成功
+                await new Promise((res) => {
+                    setTimeout(() => {
+                        res();
+                    }, 1000);
+                });
+            }
+            if (state.value.isLogin !== true) {
+                setImInfo(data);
+                uni.$emit('loginIm');
+            }
+        }
+        catch (e) { }
+    }
+    return {
+        state,
+        setImInfo,
+        resetState,
+        waitImLogin,
+        waitImReady,
+        getImInfo,
+    };
+});

package/lib/stores/index.d.ts

@@ -0,0 +1,12 @@
+import type { App } from 'vue';
+export { pinia } from './pinia';
+export * from './app';
+export * from './dict';
+export * from './im';
+export * from './launch';
+export * from './location';
+export * from './login';
+export * from './network';
+export * from './system';
+/** 安装 Pinia，插件安装时调用 */
+export declare function installStore(app: App): void;

package/lib/stores/index.js

@@ -0,0 +1,17 @@
+import { pinia } from './pinia';
+import { useLoginStore } from './login';
+export { pinia } from './pinia';
+export * from './app';
+export * from './dict';
+export * from './im';
+export * from './launch';
+export * from './location';
+export * from './login';
+export * from './network';
+export * from './system';
+/** 安装 Pinia，插件安装时调用 */
+export function installStore(app) {
+    app.use(pinia);
+    // 提前初始化登录态，保证请求拦截器在首次请求前能读取 tenantId / accessToken
+    useLoginStore(pinia);
+}

package/lib/stores/launch.d.ts

@@ -0,0 +1,42 @@
+export interface LaunchInfo {
+    id: number;
+    path: string;
+    query: Record<string, any>;
+    referrerInfo: Record<string, any>;
+    scene: number;
+}
+/** 启动参数 */
+export declare const useLaunchStore: import("pinia").StoreDefinition<"launch", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<{
+        id: number;
+        path: string;
+        query: Record<string, any>;
+        referrerInfo: Record<string, any>;
+        scene: number;
+    }>;
+    key: import("vue").Ref<number>;
+    setLaunchInfo: (data?: Partial<LaunchInfo> | null) => void;
+    setLaunchId: (id?: number) => void;
+}, "key" | "state">>, Pick<{
+    state: import("vue").Ref<{
+        id: number;
+        path: string;
+        query: Record<string, any>;
+        referrerInfo: Record<string, any>;
+        scene: number;
+    }>;
+    key: import("vue").Ref<number>;
+    setLaunchInfo: (data?: Partial<LaunchInfo> | null) => void;
+    setLaunchId: (id?: number) => void;
+}, never>, Pick<{
+    state: import("vue").Ref<{
+        id: number;
+        path: string;
+        query: Record<string, any>;
+        referrerInfo: Record<string, any>;
+        scene: number;
+    }>;
+    key: import("vue").Ref<number>;
+    setLaunchInfo: (data?: Partial<LaunchInfo> | null) => void;
+    setLaunchId: (id?: number) => void;
+}, "setLaunchInfo" | "setLaunchId">>;

package/lib/stores/launch.js

@@ -0,0 +1,39 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import { getStorageSync, setStorage } from '../utils/storage';
+import { TYPES } from '../utils/consts';
+function getDefaultState() {
+    return {
+        id: 0,
+        path: '',
+        query: {},
+        referrerInfo: {},
+        scene: 0,
+    };
+}
+/** 启动参数 */
+export const useLaunchStore = defineStore('launch', () => {
+    const storedKey = getStorageSync(TYPES.STORAGE.LAUNCH);
+    const state = ref(getDefaultState());
+    const key = ref(typeof storedKey === 'number' ? storedKey : Number(storedKey) || 0);
+    function setLaunchInfo(data) {
+        let { scene, path } = (data || {});
+        if (scene === null) {
+            scene = 0;
+        }
+        if (path && !path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        Object.assign(state.value, data, { scene, path });
+    }
+    function setLaunchId(id) {
+        key.value = id || 0;
+        setStorage(TYPES.STORAGE.LAUNCH, key.value);
+    }
+    return {
+        state,
+        key,
+        setLaunchInfo,
+        setLaunchId,
+    };
+});

package/lib/stores/location.d.ts

@@ -0,0 +1,35 @@
+export interface LocationInfo {
+    name: string;
+    address: Record<string, any>;
+    longitude: number;
+    latitude: number;
+}
+/** 定位信息 */
+export declare const useLocationStore: import("pinia").StoreDefinition<"location", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<{
+        name: string;
+        address: Record<string, any>;
+        longitude: number;
+        latitude: number;
+    }>;
+    setLocationInfo: (data: Partial<LocationInfo>) => void;
+    getLocationInfo: (options?: any) => Promise<void>;
+}, "state">>, Pick<{
+    state: import("vue").Ref<{
+        name: string;
+        address: Record<string, any>;
+        longitude: number;
+        latitude: number;
+    }>;
+    setLocationInfo: (data: Partial<LocationInfo>) => void;
+    getLocationInfo: (options?: any) => Promise<void>;
+}, never>, Pick<{
+    state: import("vue").Ref<{
+        name: string;
+        address: Record<string, any>;
+        longitude: number;
+        latitude: number;
+    }>;
+    setLocationInfo: (data: Partial<LocationInfo>) => void;
+    getLocationInfo: (options?: any) => Promise<void>;
+}, "setLocationInfo" | "getLocationInfo">>;

package/lib/stores/location.js

@@ -0,0 +1,58 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import { requestPermission } from '../utils/permission';
+import { getStorageSync, setStorage } from '../utils/storage';
+import { TYPES } from '../utils/consts';
+function getDefaultState() {
+    return {
+        name: '北京', // 城市名称
+        address: {}, // 地址信息
+        longitude: 0, // 经度
+        latitude: 0, // 纬度
+    };
+}
+/** 定位信息 */
+export const useLocationStore = defineStore('location', () => {
+    const state = ref({ ...getDefaultState(), ...(getStorageSync(TYPES.STORAGE.LOCATION) || {}) });
+    function setLocationInfo(data) {
+        state.value = {
+            ...state.value,
+            ...data,
+        };
+        setStorage(TYPES.STORAGE.LOCATION, state.value);
+    }
+    async function getLocationInfo(options = {}) {
+        await requestPermission('location');
+        return await new Promise((res) => {
+            uni.getLocation({
+                ...options,
+                geocode: true,
+                type: 'gcj02',
+                success: ({ latitude, longitude, address }) => {
+                    if (!address) {
+                        address = {};
+                    }
+                    if (Array.isArray(address.city)) {
+                        address.city = address.city[0];
+                    }
+                    const data = {
+                        name: address.city || address.province,
+                        latitude,
+                        longitude,
+                        address,
+                    };
+                    setLocationInfo(data);
+                    res();
+                },
+                fail() {
+                    res();
+                },
+            });
+        });
+    }
+    return {
+        state,
+        setLocationInfo,
+        getLocationInfo,
+    };
+});

package/lib/stores/login.d.ts

@@ -0,0 +1,80 @@
+export interface LoginInfo {
+    accessToken: string | null;
+    refreshToken: string;
+    expiresTime: number;
+    phone: string;
+    email: string;
+    nickName: string;
+    userId: string;
+    username: string;
+    avatar: string;
+    storeId: string;
+    storeName: string;
+    tenantId: string;
+    tenantName: string;
+}
+/** 登录态 */
+export declare const useLoginStore: import("pinia").StoreDefinition<"login", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<{
+        accessToken: string | null;
+        refreshToken: string;
+        expiresTime: number;
+        phone: string;
+        email: string;
+        nickName: string;
+        userId: string;
+        username: string;
+        avatar: string;
+        storeId: string;
+        storeName: string;
+        tenantId: string;
+        tenantName: string;
+    }>;
+    isLogin: import("vue").ComputedRef<boolean>;
+    setLoginInfo: (data: Partial<LoginInfo>) => void;
+    resetState: () => void;
+    logout: (reLaunch?: boolean) => void;
+    refreshToken: () => Promise<void>;
+}, "state">>, Pick<{
+    state: import("vue").Ref<{
+        accessToken: string | null;
+        refreshToken: string;
+        expiresTime: number;
+        phone: string;
+        email: string;
+        nickName: string;
+        userId: string;
+        username: string;
+        avatar: string;
+        storeId: string;
+        storeName: string;
+        tenantId: string;
+        tenantName: string;
+    }>;
+    isLogin: import("vue").ComputedRef<boolean>;
+    setLoginInfo: (data: Partial<LoginInfo>) => void;
+    resetState: () => void;
+    logout: (reLaunch?: boolean) => void;
+    refreshToken: () => Promise<void>;
+}, "isLogin">, Pick<{
+    state: import("vue").Ref<{
+        accessToken: string | null;
+        refreshToken: string;
+        expiresTime: number;
+        phone: string;
+        email: string;
+        nickName: string;
+        userId: string;
+        username: string;
+        avatar: string;
+        storeId: string;
+        storeName: string;
+        tenantId: string;
+        tenantName: string;
+    }>;
+    isLogin: import("vue").ComputedRef<boolean>;
+    setLoginInfo: (data: Partial<LoginInfo>) => void;
+    resetState: () => void;
+    logout: (reLaunch?: boolean) => void;
+    refreshToken: () => Promise<void>;
+}, "refreshToken" | "setLoginInfo" | "resetState" | "logout">>;

package/lib/stores/login.js

@@ -0,0 +1,91 @@
+import { computed, ref } from 'vue';
+import { defineStore } from 'pinia';
+import throttle from '@zfqh/uview-x/utils/throttle';
+import { getStorageSync, setStorage, removeStorage } from '../utils/storage';
+import { TYPES } from '../utils/consts';
+import query from '../utils/query';
+import navigate from '../utils/navigate';
+import { getPage } from '../utils/pages';
+import { postRefreshToken } from '../apis/core';
+const _accessToken = query.accessToken || query.token || null;
+function getDefaultState() {
+    return {
+        accessToken: null,
+        refreshToken: '',
+        expiresTime: 0,
+        phone: '',
+        email: '',
+        nickName: '',
+        userId: '',
+        username: '',
+        avatar: '',
+        storeId: '',
+        storeName: '',
+        tenantId: '',
+        tenantName: '',
+    };
+}
+function getInitialState() {
+    const defaultState = getDefaultState();
+    if (_accessToken) {
+        Object.keys(defaultState).forEach((key) => {
+            if (query[key] != null) {
+                defaultState[key] = query[key];
+            }
+        });
+        defaultState.accessToken = _accessToken;
+        return defaultState;
+    }
+    return { ...defaultState, ...(getStorageSync(TYPES.STORAGE.LOGIN) || {}) };
+}
+/** 登录态 */
+export const useLoginStore = defineStore('login', () => {
+    const state = ref(getInitialState());
+    const isLogin = computed(() => Boolean(state.value.accessToken));
+    function setLoginInfo(data) {
+        const next = { ...data };
+        if (next.accessToken) {
+            next.accessToken = next.accessToken.replace(/^bearer\s+/i, '');
+        }
+        state.value = { ...state.value, ...next };
+        if (!_accessToken) {
+            setStorage(TYPES.STORAGE.LOGIN, state.value);
+        }
+    }
+    function resetState() {
+        state.value = getDefaultState();
+        removeStorage(TYPES.STORAGE.LOGIN);
+    }
+    function logout(reLaunch) {
+        throttle(() => {
+            if (isLogin.value) {
+                resetState();
+            }
+            if (reLaunch) {
+                uni.reLaunch({ url: getPage('login') });
+            }
+            else {
+                navigate({ url: '', needLogin: true });
+            }
+        });
+    }
+    async function refreshToken() {
+        const refreshToken = state.value.refreshToken;
+        if (!refreshToken)
+            return;
+        try {
+            const { data } = await postRefreshToken({ refreshToken });
+            const { refreshToken: newRefreshToken, accessToken, expiresTime } = data || {};
+            setLoginInfo({ accessToken, refreshToken: newRefreshToken, expiresTime });
+        }
+        catch (e) { }
+    }
+    return {
+        state,
+        isLogin,
+        setLoginInfo,
+        resetState,
+        logout,
+        refreshToken,
+    };
+});

package/lib/stores/network.d.ts

@@ -0,0 +1,26 @@
+export interface NetworkInfo {
+    type: string;
+}
+/** 网络状态 */
+export declare const useNetworkStore: import("pinia").StoreDefinition<"network", import("pinia")._UnwrapAll<Pick<{
+    state: import("vue").Ref<{
+        type: string;
+    }>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    setNetworkInfo: (data: Partial<NetworkInfo>) => void;
+    getNetworkInfo: () => Promise<NetworkInfo>;
+}, "state">>, Pick<{
+    state: import("vue").Ref<{
+        type: string;
+    }>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    setNetworkInfo: (data: Partial<NetworkInfo>) => void;
+    getNetworkInfo: () => Promise<NetworkInfo>;
+}, "isConnected">, Pick<{
+    state: import("vue").Ref<{
+        type: string;
+    }>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    setNetworkInfo: (data: Partial<NetworkInfo>) => void;
+    getNetworkInfo: () => Promise<NetworkInfo>;
+}, "setNetworkInfo" | "getNetworkInfo">>;

package/lib/stores/network.js

@@ -0,0 +1,45 @@
+import { computed, ref } from 'vue';
+import { defineStore } from 'pinia';
+function getDefaultState() {
+    return {
+        type: 'unknown',
+    };
+}
+/** 网络状态 */
+export const useNetworkStore = defineStore('network', () => {
+    const state = ref(getDefaultState());
+    const isConnected = computed(() => state.value.type !== 'none');
+    function setNetworkInfo(data) {
+        Object.assign(state.value, data);
+    }
+    function getNetworkInfo() {
+        return new Promise((res) => {
+            // uni-app x App 等平台可能不提供 uni.getNetworkType：降级为 unknown，避免启动期抛错
+            const getNetworkType = uni.getNetworkType;
+            if (typeof getNetworkType !== 'function') {
+                const data = { type: 'unknown' };
+                setNetworkInfo(data);
+                res(data);
+                return;
+            }
+            getNetworkType({
+                success: (e) => {
+                    const data = { type: e.networkType };
+                    setNetworkInfo(data);
+                    res(data);
+                },
+                fail: () => {
+                    const data = { type: 'none' };
+                    setNetworkInfo(data);
+                    res(data);
+                },
+            });
+        });
+    }
+    return {
+        state,
+        isConnected,
+        setNetworkInfo,
+        getNetworkInfo,
+    };
+});