sard-uniapp 1.19.4 → 1.20.0

package/utils/request.d.ts

@@ -0,0 +1,227 @@
+interface UploadFileOptionFiles {
+    /**
+     * multipart 提交时，表单的项目名，默认为 file，如果 name 不填或填的值相同，可能导致服务端读取文件时只能读取到一个文件。
+     */
+    name?: string;
+    /**
+     * 要上传的文件对象
+     */
+    file?: File;
+    /**
+     * 要上传文件资源的路径
+     */
+    uri?: string;
+}
+export interface RequestConfig<D extends string | AnyObject | ArrayBuffer = any, E extends Record<string, any> = any, Task extends UniApp.RequestTask | UniApp.UploadTask | UniApp.DownloadTask = UniApp.RequestTask> {
+    /**
+     * 自动加在 `url` 前面，除非 `url` 是一个绝对 URL
+     */
+    baseURL?: string;
+    /**
+     * 与请求一起发送的 URL 参数
+     */
+    params?: AnyObject;
+    /**
+     * 获取 uni.request 返回值，可用于中断请求
+     */
+    getTask?: (task: Task, config: RequestConfig<D, E>) => void;
+    /**
+     * 请求的参数
+     */
+    data?: D;
+    /**
+     * 额外的请求参数，用于实现自定义的行为
+     */
+    extra?: E;
+    /**
+     * 资源url
+     */
+    url?: string;
+    /**
+     * 设置请求的 header，header 中不能设置 Referer。
+     */
+    header?: any;
+    /**
+     * 默认为 GET
+     * 可以是：OPTIONS，GET，HEAD，POST，PUT，DELETE，TRACE，CONNECT
+     */
+    method?: 'OPTIONS' | 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' | 'CONNECT' | 'DOWNLOAD' | 'UPLOAD';
+    /**
+     * 超时时间
+     */
+    timeout?: number;
+    /**
+     * 如果设为json，会尝试对返回的数据做一次 JSON.parse
+     */
+    dataType?: string;
+    /**
+     * 设置响应的数据类型。合法值：text、arraybuffer
+     */
+    responseType?: string;
+    /**
+     * 验证 ssl 证书
+     */
+    sslVerify?: boolean;
+    /**
+     * 跨域请求时是否携带凭证
+     */
+    withCredentials?: boolean;
+    /**
+     * DNS解析时优先使用 ipv4
+     */
+    firstIpv4?: boolean;
+    /**
+     * 开启 http2
+     */
+    enableHttp2?: boolean;
+    /**
+     * 开启 quic
+     */
+    enableQuic?: boolean;
+    /**
+     * 开启 cache
+     */
+    enableCache?: boolean;
+    /**
+     * 是否开启 HttpDNS 服务。如开启，需要同时填入 httpDNSServiceId 。 HttpDNS 用法详见 [移动解析HttpDNS](https://developers.weixin.qq.com/miniprogram/dev/framework/ability/HTTPDNS.html)
+     */
+    enableHttpDNS?: boolean;
+    /**
+     * HttpDNS 服务商 Id。 HttpDNS 用法详见 [移动解析HttpDNS](https://developers.weixin.qq.com/miniprogram/dev/framework/ability/HTTPDNS.html)
+     */
+    httpDNSServiceId?: boolean;
+    /**
+     * 开启 transfer-encoding chunked
+     */
+    enableChunked?: boolean;
+    /**
+     * wifi下使用移动网络发送请求
+     */
+    forceCellularNetwork?: boolean;
+    /**
+     * 默认 false，开启后可在headers中编辑cookie（支付宝小程序10.2.33版本开始支持）
+     */
+    enableCookie?: boolean;
+    /**
+     * 是否开启云加速（详见[云加速服务](https://smartprogram.baidu.com/docs/develop/extended/component-codeless/cloud-speed/introduction/)）
+     */
+    cloudCache?: object | boolean;
+    /**
+     * 控制当前请求是否延时至首屏内容渲染后发送
+     */
+    defer?: boolean;
+    /**
+     * 需要上传的文件列表。App、H5（ 2.6.15+）
+     */
+    files?: UploadFileOptionFiles[];
+    /**
+     * 文件类型，image/video/audio，仅支付宝小程序，且必填。
+     * - image: 图像
+     * - video: 视频
+     * - audio: 音频
+     */
+    fileType?: 'image' | 'video' | 'audio';
+    /**
+     * 要上传的文件对象。	仅H5（2.6.15+）支持
+     */
+    file?: File;
+    /**
+     * 要上传/下载文件资源的路径
+     */
+    filePath?: string;
+    /**
+     * 文件对应的 key , 开发者在服务器端通过这个 key 可以获取到文件二进制内容
+     */
+    name?: string;
+    /**
+     * HTTP 请求中其他额外的 form data
+     */
+    formData?: AnyObject;
+}
+export interface Response<T = any, D extends string | AnyObject | ArrayBuffer = any> {
+    /**
+     * 开发者服务器返回的数据
+     */
+    data: T;
+    /**
+     * 开发者服务器返回的 HTTP 状态码
+     */
+    statusCode: number;
+    /**
+     * 开发者服务器返回的 HTTP Response Header
+     */
+    header: any;
+    /**
+     * 开发者服务器返回的 cookies，格式为字符串数组
+     */
+    cookies: string[];
+    /**
+     * 请求的配置信息
+     */
+    config: RequestConfig<D>;
+    /**
+     * 错误信息
+     */
+    errMsg: string;
+    /**
+     * 临时文件路径，下载后的文件会存储到一个临时文件。微信小程序、支付宝小程序、百度小程序、抖音小程序、飞书小程序
+     */
+    tempFilePath: string;
+    /**
+     * 下载文件保存的路径（本地临时文件）。入参未指定 filePath 的情况下可用。支付宝小程序
+     */
+    apFilePath: string;
+    /**
+     * 用户文件路径 (本地路径)。传入 filePath 时会返回，跟传入的 filePath 一致。微信小程序、支付宝小程序、抖音小程序、飞书小程序
+     */
+    filePath: string;
+    /**
+     * 文件内容。QQ小程序
+     */
+    fileContent?: any;
+    /**
+     * 需要基础库： `2.10.4`
+     *
+     * 网络请求过程中一些调试信息，[查看详细说明](https://developers.weixin.qq.com/miniprogram/dev/framework/performance/network.html)
+     */
+    profile?: UniApp.RequestProfile;
+}
+export interface ErrorResponse<D extends string | AnyObject | ArrayBuffer = any> {
+    /**
+     * 请求的配置信息
+     */
+    config: RequestConfig<D>;
+    /**
+     * 错误信息
+     */
+    errMsg: string;
+}
+declare function createInterceptors<T, U, E>(): {
+    request: {
+        use: (onFulfilled: (value: T) => T | Promise<T>, onRejected?: ((error: E) => any) | null | undefined) => void;
+        resolve: (data: T) => Promise<T>;
+        reject: (error: any) => Promise<any>;
+    };
+    response: {
+        use: (onFulfilled: (value: U) => U | Promise<U>, onRejected?: ((error: E) => any) | null | undefined) => void;
+        resolve: (data: U) => Promise<U>;
+        reject: (error: any) => Promise<any>;
+    };
+};
+export declare class Request<E extends Record<string, any> = any> {
+    readonly interceptors: ReturnType<typeof createInterceptors<RequestConfig<any, E, any>, Response, ErrorResponse>>;
+    protected defaultConfig: RequestConfig;
+    constructor(defaultConfig?: RequestConfig);
+    request<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any, Task extends UniApp.RequestTask | UniApp.UploadTask | UniApp.DownloadTask = UniApp.RequestTask>(config: RequestConfig<D, E, Task>): Promise<R>;
+    get<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, config?: RequestConfig<D, E>): Promise<R>;
+    head<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, config?: RequestConfig<D, E>): Promise<R>;
+    connect<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, config?: RequestConfig<D, E>): Promise<R>;
+    trace<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, config?: RequestConfig<D, E>): Promise<R>;
+    post<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, data?: D, config?: RequestConfig<D, E>): Promise<R>;
+    put<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, data?: D, config?: RequestConfig<D, E>): Promise<R>;
+    delete<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, data?: D, config?: RequestConfig<D, E>): Promise<R>;
+    options<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, data?: D, config?: RequestConfig<D, E>): Promise<R>;
+    upload<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, config?: RequestConfig<D, E, UniApp.UploadTask>): Promise<R>;
+    download<T = any, R = Response<T>, D extends string | AnyObject | ArrayBuffer = any>(url: string, config?: RequestConfig<D, E, UniApp.DownloadTask>): Promise<R>;
+}
+export {};

package/utils/request.js

@@ -0,0 +1,249 @@
+import { URLQuery } from './url-query';
+function reducerFactory() {
+    const handlers = [];
+    function use(onFulfilled, onRejected) {
+        handlers.push({
+            fulfilled: onFulfilled,
+            rejected: onRejected,
+        });
+    }
+    async function resolve(data) {
+        for (const { fulfilled } of handlers) {
+            try {
+                data = await fulfilled(data);
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        }
+        return Promise.resolve(data);
+    }
+    async function reject(error) {
+        for (const { rejected } of handlers) {
+            try {
+                if (rejected) {
+                    const data = await rejected(error);
+                    return Promise.resolve(data);
+                }
+            }
+            catch (newError) {
+                error = newError;
+            }
+        }
+        return Promise.reject(error);
+    }
+    return {
+        use,
+        resolve,
+        reject,
+    };
+}
+function createInterceptors() {
+    return {
+        request: reducerFactory(),
+        response: reducerFactory(),
+    };
+}
+const defaultRequestConfig = {};
+function mergeConfig(...configs) {
+    return configs.reduce((result, config) => {
+        return {
+            ...result,
+            ...config,
+            header: {
+                ...result.header,
+                ...config.header,
+            },
+            params: {
+                ...result.params,
+                ...config.params,
+            },
+            extra: {
+                ...result.extra,
+                ...config.extra,
+            },
+        };
+    }, {});
+}
+function mergeUrl(options) {
+    const { baseURL = '', url = '', params } = options;
+    let mergedUrl = '';
+    if (/^(https?:)?\/\//.test(url)) {
+        mergedUrl = url;
+    }
+    else if (baseURL && url) {
+        mergedUrl = baseURL.replace(/\/*$/, '') + '/' + url.replace(/^\/*/, '');
+    }
+    else if (baseURL) {
+        mergedUrl = baseURL;
+    }
+    else if (url) {
+        mergedUrl = url;
+    }
+    if (params) {
+        const query = new URLQuery(params);
+        const index = mergedUrl.indexOf('?');
+        if (index !== -1) {
+            const originPath = mergedUrl.slice(index);
+            const search = mergedUrl.slice(index);
+            mergedUrl +=
+                originPath +
+                    '?' +
+                    new URLQuery([...query, ...new URLQuery(search)]).toString();
+        }
+        else {
+            mergedUrl += '?' + query.toString();
+        }
+    }
+    return mergedUrl;
+}
+export class Request {
+    interceptors;
+    defaultConfig;
+    constructor(defaultConfig = {}) {
+        this.defaultConfig = mergeConfig(defaultRequestConfig, defaultConfig);
+        this.interceptors = createInterceptors();
+    }
+    request(config) {
+        return new Promise((resolve, reject) => {
+            const interceptors = this.interceptors;
+            config = mergeConfig(this.defaultConfig, config);
+            interceptors.request
+                .resolve(config)
+                .then((config) => {
+                const { baseURL, params, getTask, url, extra, ...rest } = config;
+                void extra;
+                const mergedUrl = mergeUrl({ baseURL, url, params });
+                const mergedConfig = {
+                    ...rest,
+                    url: mergedUrl,
+                    success(result) {
+                        const { data, statusCode, header = {}, cookies = [], errMsg = '', tempFilePath = '', apFilePath = '', filePath = '', fileContent, profile, } = result;
+                        let parsedData = data;
+                        if (typeof data === 'string') {
+                            try {
+                                parsedData = JSON.parse(data);
+                            }
+                            catch {
+                                void 0;
+                            }
+                        }
+                        interceptors.response
+                            .resolve({
+                            data: parsedData,
+                            statusCode,
+                            header,
+                            cookies,
+                            errMsg,
+                            tempFilePath,
+                            apFilePath,
+                            filePath,
+                            fileContent,
+                            profile,
+                            config,
+                        })
+                            .then(resolve, reject);
+                    },
+                    fail(result) {
+                        interceptors.response
+                            .reject({
+                            ...result,
+                            config,
+                        })
+                            .then(resolve, reject);
+                    },
+                };
+                let task;
+                switch (config.method) {
+                    case 'DOWNLOAD':
+                        task = uni.downloadFile(mergedConfig);
+                        break;
+                    case 'UPLOAD':
+                        task = uni.uploadFile(mergedConfig);
+                        break;
+                    default:
+                        task = uni.request(mergedConfig);
+                        break;
+                }
+                if (getTask) {
+                    getTask(task, config);
+                }
+            })
+                .catch(reject);
+        });
+    }
+    get(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'GET',
+        });
+    }
+    head(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'HEAD',
+        });
+    }
+    connect(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'CONNECT',
+        });
+    }
+    trace(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'TRACE',
+        });
+    }
+    post(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            data,
+            method: 'POST',
+        });
+    }
+    put(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            data,
+            method: 'PUT',
+        });
+    }
+    delete(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            data,
+            method: 'DELETE',
+        });
+    }
+    options(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            data,
+            method: 'OPTIONS',
+        });
+    }
+    upload(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'UPLOAD',
+        });
+    }
+    download(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'DOWNLOAD',
+        });
+    }
+}

package/utils/router.d.ts

@@ -0,0 +1,47 @@
+interface RouterExtraOptions {
+    query?: Record<string, any>;
+}
+interface Route {
+    url: string;
+    query?: Record<string, any>;
+}
+export interface PagesPath {
+}
+type ChangeOptionsUrl<T extends {
+    url: string.PageURIString;
+}> = Omit<T, 'url'> & {
+    url: (string & {}) | PagesPath['path' extends keyof PagesPath ? 'path' : never];
+};
+type RouterGuard = (to: Route, from: Route) => boolean | undefined | null | void | string | Route | Promise<boolean | undefined | null | void | string | Route>;
+export declare class Router {
+    status: 'idle' | 'busy';
+    guards: RouterGuard[];
+    protected resolvePath(currentPath: string, path: string): string;
+    protected parseQuery(url: string): {
+        url: string;
+        query?: Record<string, string>;
+    };
+    protected getPathQuery(currentPath: string, route: string | Route): {
+        url: string;
+        query: {
+            [x: string]: any;
+        };
+    };
+    protected makeUniRouteOptions(to: {
+        url: string;
+        query: Record<string, any>;
+    }, options: any): any;
+    protected intercept(options: {
+        url: string;
+        success?: (result: any) => void;
+        fail?: (result: any) => void;
+        complete?: (result: any) => void;
+    } & RouterExtraOptions, action: (...args: any[]) => any): Promise<any>;
+    navigateTo(options: ChangeOptionsUrl<UniApp.NavigateToOptions> & RouterExtraOptions): Promise<any>;
+    redirectTo(options: ChangeOptionsUrl<UniApp.RedirectToOptions> & RouterExtraOptions): Promise<any>;
+    reLaunch(options: ChangeOptionsUrl<UniApp.ReLaunchOptions> & RouterExtraOptions): Promise<any>;
+    switchTab(options: ChangeOptionsUrl<UniApp.SwitchTabOptions>): Promise<any>;
+    navigateBack(options: UniApp.NavigateBackOptions): Promise<any>;
+    beforeEach(guard: RouterGuard): void;
+}
+export {};

package/utils/router.js

@@ -0,0 +1,115 @@
+import { URLQuery } from './url-query';
+export class Router {
+    status = 'idle';
+    guards = [];
+    resolvePath(currentPath, path) {
+        if (/^\//.test(path)) {
+            return path;
+        }
+        const fragments = currentPath.replace(/\/[^/]+$/, '').split('/');
+        if (path.startsWith('./')) {
+            path = path.slice(2);
+        }
+        fragments.push(...path.split('/'));
+        const count = fragments.filter((frag) => frag === '..').length;
+        for (let i = 0; i < count; i++) {
+            const index = fragments.indexOf('..');
+            fragments.splice(index - 1, 2);
+        }
+        return '/' + fragments.join('/');
+    }
+    parseQuery(url) {
+        const [pathPart, queryPart] = url.split('?');
+        const pathQuery = {
+            url: pathPart,
+        };
+        if (queryPart) {
+            pathQuery.query = Object.fromEntries(new URLQuery(queryPart));
+        }
+        return pathQuery;
+    }
+    getPathQuery(currentPath, route) {
+        const toRoute = typeof route === 'string'
+            ? this.parseQuery(route)
+            : this.parseQuery(route.url);
+        return {
+            url: this.resolvePath(currentPath, toRoute.url),
+            query: {
+                ...toRoute.query,
+                ...(typeof route !== 'string' ? route.query : null),
+            },
+        };
+    }
+    makeUniRouteOptions(to, options) {
+        const url = to.url +
+            (Object.keys(to.query).length > 0
+                ? '?' + new URLQuery(Object.entries(to.query)).toString()
+                : '');
+        return {
+            ...options,
+            url,
+        };
+    }
+    async intercept(options, action) {
+        if (this.status === 'busy') {
+            return;
+        }
+        this.status = 'busy';
+        const complete = options.complete;
+        options.complete = (result) => {
+            this.status = 'idle';
+            complete?.(result);
+        };
+        const pages = getCurrentPages();
+        const currentPath = pages[pages.length - 1].route;
+        const toPathQuery = this.getPathQuery(currentPath, {
+            url: options.url,
+            query: options.query,
+        });
+        const fromPathQuery = {
+            url: '/' + currentPath,
+            query: {},
+        };
+        try {
+            for (const guard of this.guards) {
+                const result = await guard(toPathQuery, fromPathQuery);
+                if (result === false) {
+                    this.status = 'idle';
+                    return;
+                }
+                if (typeof result === 'string') {
+                    return action(this.makeUniRouteOptions(this.getPathQuery(currentPath, result), options));
+                }
+                if (result !== null && typeof result === 'object') {
+                    return action(this.makeUniRouteOptions(this.getPathQuery(currentPath, result), options));
+                }
+            }
+        }
+        catch (err) {
+            this.status = 'idle';
+            console.error(err);
+            return;
+        }
+        return action(this.makeUniRouteOptions(toPathQuery, options));
+    }
+    navigateTo(options) {
+        return this.intercept(options, uni.navigateTo);
+    }
+    redirectTo(options) {
+        return this.intercept(options, uni.redirectTo);
+    }
+    reLaunch(options) {
+        return this.intercept(options, uni.reLaunch);
+    }
+    switchTab(options) {
+        return this.intercept(options, uni.switchTab);
+    }
+    navigateBack(options) {
+        return uni.navigateBack(options);
+    }
+    beforeEach(guard) {
+        if (!this.guards.includes(guard)) {
+            this.guards.push(guard);
+        }
+    }
+}

package/utils/string.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 将字符串首字母转换为小写格式。
+ */
+export declare function lowerFirst(string: string): string;
+/**
+ * 将字符串首字母转换为大写格式。
+ */
+export declare function upperFirst(string: string): string;
+/**
+ * 将字符串转换为 PascalCase 格式（大驼峰）。
+ */
+export declare function pascalCase(string: string): string;
+/**
+ * 将字符串转换为 camelCase 格式（小驼峰）。
+ */
+export declare function camelCase(string: string): string;
+/**
+ * 将字符串转换为 Capitalize 格式（首字母大写，其余小写）。
+ */
+export declare function capitalize(string: string): string;
+/**
+ * 将字符串转换为 kebab-case 格式（使用连字符拼接单词）。
+ */
+export declare function kebabCase(string: string): string;
+/**
+ * 将字符串转换为 snake_case 格式（使用下划线拼接单词）。
+ */
+export declare function snakeCase(string: string): string;
+/**
+ * 每n位数字添加一个分隔符
+ */
+export declare function addSeparator(num: number | string, separator?: string, digit?: number): string;
+/**
+ * 生成唯一ID，用于设置元素的ID，以便获取
+ */
+export declare function uniqid(prefix?: string): string;
+export type ClassProp = string | number | null | undefined | Record<string, any> | ClassProp[];
+/**
+ * 把各种类型的参数拼接成字符串类名，以便解决小程序不支持 classObject 的问题
+ */
+export declare function classNames(...args: ClassProp[]): string;
+export type StyleProp = string | Record<any, any> | null | undefined | false | StyleProp[];
+/**
+ * 把样式对象拼接成字符串，解决小程序不支持 styleObject 的问题。
+ */
+export declare function stringifyStyle(...args: StyleProp[]): string;