@hlw-uni/mp-vue 2.1.51 → 2.1.54

package/src/composables/navigator/index.ts

@@ -1,104 +1,104 @@
 /**
- * 路由/跳转能力 —— 包装 uni-app 各类 jump API 为一个统一对象
- *
- * 使用：
- *   const { navigate } = useRouter();
- *   navigate(tool.jump_type, tool.jump_value);
- *
- * 未装 vue-router 也能用；命名风格对齐 Vue Router，熟悉的 push/replace/back
- * 会在后续迭代中补齐。
+ * useNavigate - uni-app 跳转工具
  */
-
-/** 已知的跳转类型；保留 `(string & {})` 允许任意自定义值向下兼容 */
 export type NavigateType =
     | "navigateTo"
     | "redirectTo"
     | "switchTab"
     | "reLaunch"
-    | "webview"
+    | "navigateBack"
     | "miniprogram"
+    | "webview"
     | (string & {});
 
 export interface NavigateOptions {
-    /** 失败回调，收到 uni 返回的错误信息 */
-    onFail?: (errMsg: string) => void;
-    /** 是否禁用默认的 Toast 错误提示，默认 false */
     silent?: boolean;
-    /** 仅 miniprogram：目标小程序的页面路径（如 pages/index/index?id=1），留空/null 则打开首页 */
-    path?: string | null;
-    /** 仅 miniprogram：目标小程序版本，默认 release */
+    onFail?: (message: string) => void;
+    delta?: number;
+    path?: string;
     envVersion?: "develop" | "trial" | "release";
-    /** 仅 miniprogram：传给目标小程序的额外数据，对方从 onLaunch/onShow 读取 */
-    extraData?: Record<string, unknown> | null;
+    extraData?: Record<string, unknown>;
 }
 
-/**
- * 根据 type + value 调用对应的 uni API，屏蔽参数差异。
- *
- * 对应关系：
- * - `navigateTo`（默认） → uni.navigateTo
- * - `redirectTo`          → uni.redirectTo
- * - `switchTab`           → uni.switchTab（value 必须是 tabBar 页）
- * - `reLaunch`            → uni.reLaunch
- * - `webview`             → 默认 Toast 提示，上层需接入 web-view 承载页
- * - `miniprogram`         → uni.navigateToMiniProgram，value 格式 `appid:path`
- */
-function doNavigate(type: NavigateType, value: string, options: NavigateOptions = {}): void {
-    const { onFail, silent = false } = options;
+type UniFail = { errMsg?: string };
 
-    if (!value) {
-        if (!silent) uni.showToast({ title: "跳转目标未配置", icon: "none" });
-        onFail?.("跳转目标未配置");
-        return;
+function fail(message: string, options: NavigateOptions = {}) {
+    if (!options.silent) {
+        uni.showToast({ title: message, icon: "none" });
     }
+    options.onFail?.(message);
+}
 
-    const fail = (err?: { errMsg?: string }) => {
-        const msg = err?.errMsg || `无法跳转：${value}`;
-        if (!silent) uni.showToast({ title: msg, icon: "none" });
-        onFail?.(msg);
+function failHandler(target: string, options: NavigateOptions = {}) {
+    return (error?: UniFail) => {
+        fail(error?.errMsg || `无法跳转：${target}`, options);
     };
+}
 
-    switch (type) {
-        case "switchTab":
-            uni.switchTab({ url: value, fail });
-            break;
-        case "redirectTo":
-            uni.redirectTo({ url: value, fail });
-            break;
-        case "reLaunch":
-            uni.reLaunch({ url: value, fail });
-            break;
-        case "webview":
-            // H5 需要上层承载页接入；这里仅 Toast 告知
-            if (!silent) uni.showToast({ title: `H5：${value}`, icon: "none" });
-            break;
-        case "miniprogram": {
-            // @ts-ignore 部分平台 navigateToMiniProgram 定义可能缺失
-            uni.navigateToMiniProgram?.({
-                appId: value,
-                path: options.path || "",
-                envVersion: options.envVersion,
-                extraData: options.extraData ?? undefined,
-                fail,
-            });
-            break;
+function navigate(type: NavigateType = "navigateTo", url = "", options: NavigateOptions = {}) {
+    if (type === "navigateBack") {
+        uni.navigateBack({ delta: options.delta || 1, fail: failHandler("返回上一页", options) });
+        return;
+    }
+
+    if (!url) {
+        fail("跳转目标未配置", options);
+        return;
+    }
+
+    const onFail = failHandler(url, options);
+
+    if (type === "redirectTo") {
+        uni.redirectTo({ url, fail: onFail });
+        return;
+    }
+
+    if (type === "switchTab") {
+        uni.switchTab({ url, fail: onFail });
+        return;
+    }
+
+    if (type === "reLaunch") {
+        uni.reLaunch({ url, fail: onFail });
+        return;
+    }
+
+    if (type === "miniprogram") {
+        const openMiniProgram = uni.navigateToMiniProgram as
+            | ((options: UniApp.NavigateToMiniProgramOptions) => void)
+            | undefined;
+
+        if (!openMiniProgram) {
+            fail("当前平台不支持打开小程序", options);
+            return;
         }
-        case "navigateTo":
-        default:
-            uni.navigateTo({ url: value, fail });
-            break;
+
+        openMiniProgram({
+            appId: url,
+            path: options.path || "",
+            envVersion: options.envVersion || "release",
+            extraData: options.extraData,
+            fail: onFail,
+        });
+        return;
+    }
+
+    if (type === "webview") {
+        fail(`H5：${url}`, options);
+        return;
     }
+
+    uni.navigateTo({ url, fail: onFail });
 }
 
-/**
- * 路由 composable：返回跳转方法集合。
- *
- * @example
- *   const { navigate } = useRouter();
- *   navigate("switchTab", "/pages/index/index");
- */
-export function useRouter() {
+export function useNavigate() {
     return {
-        navigate: doNavigate,
+        navigate,
+        to: (url: string, options?: NavigateOptions) => navigate("navigateTo", url, options),
+        redirect: (url: string, options?: NavigateOptions) => navigate("redirectTo", url, options),
+        tab: (url: string, options?: NavigateOptions) => navigate("switchTab", url, options),
+        reLaunch: (url: string, options?: NavigateOptions) => navigate("reLaunch", url, options),
+        back: (delta = 1, options: NavigateOptions = {}) => navigate("navigateBack", "", { ...options, delta }),
+        miniProgram: (appId: string, options?: NavigateOptions) => navigate("miniprogram", appId, options),
     };
 }

package/src/composables/request/client.ts

@@ -0,0 +1,204 @@
+import { ref } from "vue";
+import type {
+    ApiResponse,
+    ErrorInterceptor,
+    RequestConfig,
+    RequestInterceptor,
+    ResponseInterceptor,
+    UploadConfig,
+    UploadResult,
+} from "./types";
+import { getAdapter } from "./adapters";
+
+export interface RequestClient {
+    request<T = unknown>(config: RequestConfig): Promise<ApiResponse<T>>;
+    get<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    del<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    upload(config: UploadConfig): Promise<UploadResult>;
+    setBaseURL(url: string): void;
+    resolveServiceUrl(namespace: string, url: string, servicePrefix?: string): string;
+    onRequest(fn: RequestInterceptor): () => void;
+    onResponse<T = unknown>(fn: ResponseInterceptor<T>): () => void;
+    onError(fn: ErrorInterceptor): () => void;
+}
+
+class UniRequestClient implements RequestClient {
+    private reqInterceptors: RequestInterceptor[] = [];
+    private resInterceptors: ResponseInterceptor[] = [];
+    private errInterceptors: ErrorInterceptor[] = [];
+    private baseURL = "";
+    private defaultHeaders: Record<string, string> = { "Content-Type": "application/json" };
+
+    setBaseURL(url: string): void {
+        this.baseURL = url;
+    }
+
+    onRequest(fn: RequestInterceptor): () => void {
+        this.reqInterceptors.push(fn);
+        return () => this.remove(this.reqInterceptors, fn);
+    }
+
+    onResponse<T = unknown>(fn: ResponseInterceptor<T>): () => void {
+        const item = fn as ResponseInterceptor;
+        this.resInterceptors.push(item);
+        return () => this.remove(this.resInterceptors, item);
+    }
+
+    onError(fn: ErrorInterceptor): () => void {
+        this.errInterceptors.push(fn);
+        return () => this.remove(this.errInterceptors, fn);
+    }
+
+    async request<T = unknown>(config: RequestConfig): Promise<ApiResponse<T>> {
+        let cfg: RequestConfig = {
+            method: "GET",
+            ...config,
+            headers: { ...this.defaultHeaders, ...config.headers },
+        };
+
+        for (const fn of this.reqInterceptors) {
+            cfg = await fn(cfg);
+        }
+
+        try {
+            const res = await this.send<T>(this.resolveUrl(cfg.url), cfg);
+            for (const fn of this.resInterceptors) {
+                const next = await fn(res as ApiResponse<unknown>);
+                if (next !== undefined) return next as ApiResponse<T>;
+            }
+            return res;
+        } catch (e) {
+            const err = e as Error;
+            for (const fn of this.errInterceptors) {
+                await fn(err);
+            }
+            throw err;
+        }
+    }
+
+    get<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "GET", data });
+    }
+
+    post<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "POST", data });
+    }
+
+    put<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "PUT", data });
+    }
+
+    del<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "DELETE", data });
+    }
+
+    upload(config: UploadConfig): Promise<UploadResult> {
+        const fileName = config.fileName ?? config.filePath.split("/").pop() ?? "file";
+        const server = config.type === "local" && config.url ? config.url : config.server;
+        const formData = config.type === "local"
+            ? (config.credentials ?? {})
+            : getAdapter(config.type).buildFormData({
+                filePath: config.filePath,
+                fileName,
+                credentials: config.credentials,
+            });
+
+        return new Promise((resolve, reject) => {
+            uni.uploadFile({
+                url: server,
+                filePath: config.filePath,
+                name: "file",
+                formData: formData as unknown as UniNamespace.UploadFileOption["formData"],
+                header: config.header as Record<string, string>,
+                success: (res) => {
+                    if (res.statusCode < 200 || res.statusCode >= 300) {
+                        reject(new Error(`上传失败: ${res.statusCode}`));
+                        return;
+                    }
+
+                    try {
+                        const body = JSON.parse(res.data);
+                        resolve({
+                            code: body.code ?? 1,
+                            msg: body.msg ?? body.message ?? "上传成功",
+                            data: body.data ?? "",
+                        });
+                    } catch {
+                        resolve({ code: 1, msg: "上传成功", data: res.data });
+                    }
+                },
+                fail: (err) => reject(new Error(err.errMsg || "上传失败")),
+            });
+        });
+    }
+
+    resolveServiceUrl(namespace: string, url: string, servicePrefix = ""): string {
+        if (isAbsolute(url)) return url;
+
+        const ns = namespace.replace(/^\/+|\/+$/g, "").replace(/\//g, ".");
+        const prefixValue = servicePrefix.replace(/^\/+|\/+$/g, "");
+        const path = url.startsWith("/") ? url : `/${url}`;
+        const prefix = [prefixValue, ns].filter(Boolean).join("/");
+
+        return prefix ? `/${prefix}${path}` : path;
+    }
+
+    private resolveUrl(url: string): string {
+        if (isAbsolute(url)) return url;
+        return `${this.baseURL}${url}`;
+    }
+
+    private send<T>(url: string, cfg: RequestConfig): Promise<ApiResponse<T>> {
+        return new Promise((resolve, reject) => {
+            uni.request({
+                url,
+                method: cfg.method,
+                data: cfg.data as UniNamespace.RequestOptions["data"],
+                header: cfg.headers as Record<string, string>,
+                timeout: cfg.timeout,
+                success: (res) => {
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(res.data as ApiResponse<T>);
+                        return;
+                    }
+
+                    const body = res.data as Record<string, unknown> | undefined;
+                    reject(new Error(String(body?.info ?? body?.message ?? `请求失败: ${res.statusCode}`)));
+                },
+                fail: (err) => reject(new Error(err.errMsg || "网络请求失败")),
+            });
+        });
+    }
+
+    private remove<T>(items: T[], item: T): void {
+        const index = items.indexOf(item);
+        if (index > -1) items.splice(index, 1);
+    }
+}
+
+function isAbsolute(url: string): boolean {
+    return /^(https?:)?\/\//.test(url) || url.startsWith("file://");
+}
+
+const requestClient = new UniRequestClient();
+
+export function useRequest(): RequestClient {
+    return requestClient;
+}
+
+export function useUpload() {
+    const uploading = ref(false);
+
+    async function upload(options: UploadConfig): Promise<UploadResult> {
+        uploading.value = true;
+        try {
+            return await requestClient.upload(options);
+        } finally {
+            uploading.value = false;
+        }
+    }
+
+    return { uploading, upload };
+}

package/src/composables/request/index.ts

@@ -0,0 +1,15 @@
+export { useRequest, useUpload } from "./client";
+export { BaseService, ServiceNamespace, ServicePrefix } from "./service";
+export type { RequestClient } from "./client";
+export type {
+    ApiResponse,
+    PageResult,
+    RequestConfig,
+    RequestInterceptor,
+    ResponseInterceptor,
+    ErrorInterceptor,
+    UploadConfig,
+    UploadResult,
+} from "./types";
+export type { ServiceNamespaceOptions, ServicePrefixOptions, ServiceRequestConfig } from "./service";
+export * from "./adapters";

package/src/composables/request/service.ts

@@ -0,0 +1,54 @@
+import { useRequest } from "./client";
+import type { ApiResponse, RequestConfig } from "./types";
+
+export type ServiceRequestConfig = Omit<RequestConfig, "url"> & {
+    url: string;
+};
+
+export interface ServiceNamespaceOptions {
+    namespace: string;
+}
+
+export interface ServicePrefixOptions {
+    prefix: string;
+}
+
+export class BaseService {
+    declare namespace: string;
+    declare servicePrefix: string;
+
+    request<T = unknown>(options: ServiceRequestConfig): Promise<ApiResponse<T>> {
+        return useRequest().request<T>({
+            ...options,
+            url: useRequest().resolveServiceUrl(this.namespace ?? "", options.url, this.servicePrefix ?? ""),
+        });
+    }
+
+    get<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "GET", data });
+    }
+
+    post<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "POST", data });
+    }
+
+    put<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "PUT", data });
+    }
+
+    del<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>> {
+        return this.request<T>({ url, method: "DELETE", data });
+    }
+}
+
+export function ServiceNamespace(value: string | ServiceNamespaceOptions) {
+    return function (target: { prototype: { namespace?: string } }) {
+        target.prototype.namespace = typeof value === "string" ? value : value.namespace;
+    };
+}
+
+export function ServicePrefix(value: string | ServicePrefixOptions) {
+    return function (target: { prototype: { servicePrefix?: string } }) {
+        target.prototype.servicePrefix = typeof value === "string" ? value : value.prefix;
+    };
+}

package/src/composables/{http → request}/types.ts

@@ -1,7 +1,3 @@
-/**
- * HTTP 类型定义
- */
-
 /** API 统一响应格式 */
 export interface ApiResponse<T = unknown> {
     code: number;