sard-uniapp 1.19.5 → 1.20.0

package/utils/string.js

@@ -0,0 +1,134 @@
+function splitWord(string) {
+    return string
+        .split(/[^a-zA-Z0-9$]+/)
+        .map((item) => item.split(/([A-Z][^A-Z]*)/))
+        .flat()
+        .filter(Boolean);
+}
+/**
+ * 将字符串首字母转换为小写格式。
+ */
+export function lowerFirst(string) {
+    return string.replace(/^[A-Z]/, (m) => m.toLowerCase());
+}
+/**
+ * 将字符串首字母转换为大写格式。
+ */
+export function upperFirst(string) {
+    return string.replace(/^[a-z]/, (m) => m.toUpperCase());
+}
+/**
+ * 将字符串转换为 PascalCase 格式（大驼峰）。
+ */
+export function pascalCase(string) {
+    return splitWord(string)
+        .map((word) => upperFirst(word.toLowerCase()))
+        .join('');
+}
+/**
+ * 将字符串转换为 camelCase 格式（小驼峰）。
+ */
+export function camelCase(string) {
+    return lowerFirst(pascalCase(string));
+}
+/**
+ * 将字符串转换为 Capitalize 格式（首字母大写，其余小写）。
+ */
+export function capitalize(string) {
+    return upperFirst(string.toLowerCase());
+}
+/**
+ * 将字符串转换为 kebab-case 格式（使用连字符拼接单词）。
+ */
+export function kebabCase(string) {
+    return splitWord(string)
+        .map((item) => item.toLowerCase())
+        .join('-');
+}
+/**
+ * 将字符串转换为 snake_case 格式（使用下划线拼接单词）。
+ */
+export function snakeCase(string) {
+    return splitWord(string)
+        .map((item) => item.toLowerCase())
+        .join('_');
+}
+/**
+ * 每n位数字添加一个分隔符
+ */
+export function addSeparator(num, separator = ',', digit = 3) {
+    return String(num).replace(new RegExp(`\\B(?=(\\d{${digit}})+(?!\\d))`, 'g'), separator);
+}
+/**
+ * 生成唯一ID，用于设置元素的ID，以便获取
+ */
+export function uniqid(prefix = '__sar_') {
+    return prefix + (~~(Math.random() * 10e8)).toString(36);
+}
+/**
+ * 把各种类型的参数拼接成字符串类名，以便解决小程序不支持 classObject 的问题
+ */
+export function classNames(...args) {
+    let result = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        if (typeof arg === 'string' || typeof arg === 'number') {
+            result += arg + ' ';
+        }
+        else if (Array.isArray(arg)) {
+            if (arg.length) {
+                const className = classNames(...arg);
+                if (className) {
+                    result += className + ' ';
+                }
+            }
+        }
+        else if (typeof arg === 'object') {
+            for (const key in arg) {
+                const value = arg[key];
+                if (value) {
+                    result += key + ' ';
+                }
+            }
+        }
+    }
+    return result;
+}
+function toKebabCase(str) {
+    return str
+        .replace(/^[A-Z]/, (m) => m.toLowerCase())
+        .replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());
+}
+/**
+ * 把样式对象拼接成字符串，解决小程序不支持 styleObject 的问题。
+ */
+export function stringifyStyle(...args) {
+    let result = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        if (typeof arg === 'string') {
+            result += arg + ';';
+        }
+        else if (Array.isArray(arg)) {
+            if (arg.length) {
+                const string = stringifyStyle(...arg);
+                if (string) {
+                    result += string + ';';
+                }
+            }
+        }
+        else if (typeof arg === 'object') {
+            for (const key in arg) {
+                const value = arg[key];
+                if (value || value === 0) {
+                    result += `${toKebabCase(key)}:${value};`;
+                }
+            }
+        }
+    }
+    return result;
+}

package/utils/url-query.d.ts

@@ -0,0 +1,19 @@
+export declare class URLQuery {
+    _params: string[][];
+    constructor(init?: string[][] | Record<string, string> | string | URLQuery);
+    _fromString(queryString: string): void;
+    get size(): number;
+    append(name: string, value: string): void;
+    delete(name: string, value?: string): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string, value?: string): boolean;
+    set(name: string, value: string): void;
+    sort(): void;
+    toString(): string;
+    forEach(callbackfn: (value: string, key: string, parent: URLQuery) => void, thisArg?: any): void;
+    entries(): ArrayIterator<string[]>;
+    keys(): Generator<string, void, unknown>;
+    values(): Generator<string, void, unknown>;
+    [Symbol.iterator](): ArrayIterator<string[]>;
+}

package/utils/url-query.js

@@ -0,0 +1,95 @@
+export class URLQuery {
+    _params = [];
+    constructor(init) {
+        this._params = [];
+        if (init) {
+            if (typeof init === 'string') {
+                this._fromString(init);
+            }
+            else if (Array.isArray(init)) {
+                init.forEach(([name, value]) => {
+                    this.append(name, value);
+                });
+            }
+            else if (typeof init === 'object') {
+                Object.entries(init).forEach(([name, value]) => {
+                    this.append(name, value);
+                });
+            }
+        }
+    }
+    // 解析查询字符串
+    _fromString(queryString) {
+        if (queryString.startsWith('?')) {
+            queryString = queryString.slice(1);
+        }
+        queryString.split('&').forEach((pair) => {
+            const [name, value = ''] = pair.split('=').map(decodeURIComponent);
+            if (name) {
+                this.append(name, value);
+            }
+        });
+    }
+    get size() {
+        return this._params.length;
+    }
+    // 添加键值对
+    append(name, value) {
+        this._params.push([String(name), String(value)]);
+    }
+    // 删除指定 name 的所有值
+    delete(name, value) {
+        this._params = this._params.filter(([k, v]) => name !== k || (value && value !== v));
+    }
+    // 获取第一个匹配的 value
+    get(name) {
+        const found = this._params.find(([k]) => k === name);
+        return found ? found[1] : null;
+    }
+    // 获取所有匹配的 values
+    getAll(name) {
+        return this._params.filter(([k]) => k === name).map(([, v]) => v);
+    }
+    // 检查是否存在 name
+    has(name, value) {
+        return this._params.some(([k, v]) => k === name && (!value || value === v));
+    }
+    // 设置 name 的值（覆盖所有旧值）
+    set(name, value) {
+        this.delete(name);
+        this.append(name, value);
+    }
+    // 按键名排序
+    sort() {
+        this._params.sort(([a], [b]) => a.localeCompare(b));
+    }
+    // 转换为查询字符串
+    toString() {
+        return this._params
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .join('&');
+    }
+    forEach(callbackfn, thisArg) {
+        this._params.forEach(([name, value]) => {
+            callbackfn.call(thisArg, value, name, this);
+        });
+    }
+    // 迭代方法
+    entries() {
+        return this._params[Symbol.iterator]();
+    }
+    *keys() {
+        for (const [name] of this._params) {
+            yield name;
+        }
+    }
+    *values() {
+        for (const [, value] of this._params) {
+            yield value;
+        }
+    }
+    // 支持 for...of 迭代
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}

package/utils/utils.d.ts

@@ -1,106 +1,3 @@
-/**
- * @description: 确保目标是一个数组
- * @param {any} target
- * @return {array}
- */
-export declare function toArray(target: any): any[];
-/**
- * @description: 限定数值范围
- * @param {number} n 被限定的值
- * @param {number} min 最小值
- * @param {number} max 最大值
- * @return {number} 限定后的值
- */
-export declare function minmax(n: number, min: number, max: number): number;
-/**
- * @description: 获取小数位数
- * @param {number | string} n 要操作的数值
- * @return {number}
- */
-export declare function getDecimalsLength(n: number | string): number;
-/**
- * @description: 把一个数四舍五入到指定位数小数
- * @param {number} n 要操作的数值
- * @param {number} precision 精准度，即小数个数
- * @return {number}
- */
-export declare function round(n: number, precision?: number): number;
-/**
- * @description: 把一个数舍入到指定数的倍数
- * @param {number} n 要舍入的数值
- * @param {number} m 结果值的因数
- * @return {number}
- */
-export declare function mround(n: number, m: number): number;
-/**
- * @description: 生成唯一ID，用于设置元素的ID，以便获取
- * @param {string} prefix
- * @return {string}
- */
-export declare function uniqid(prefix?: string): string;
-/**
- * @description: 获取阻尼值
- * @param {number} value
- * @param {number} min
- * @param {number} max
- * @param {number} damping
- * @return {number}
- */
-export declare function getDampingValue(value: number, min: number, max: number, damping: number): number;
-/**
- * @description: 获取矩形阻尼值
- * @param {number} offset 当前的偏移量
- * @param {number} areaSize 范围值
- * @param {number} viewSize 范围内某个视图尺寸值
- * @param {number} damping 阻尼系数
- * @return {number}
- */
-export declare function getRectDampingValue(offset: number, areaSize: number, viewSize: number, damping: number): number;
-/**
- * @description: 获取范围值
- * @param {number} offset 当前的偏移量
- * @param {number} areaSize 范围值
- * @param {number} viewSize 范围内某个视图尺寸值
- * @return {number}
- */
-export declare function getInBoundValue(offset: number, areaSize: number, viewSize: number): number;
-/**
- * @description: 获取溢出值范围
- * @param {number} overflow 最大溢出值
- * @param {number} areaSize 范围值
- * @param {number} viewSize 范围内某个视图尺寸值
- * @return {*}
- */
-export declare function getOverflowRangeInArea(overflow: number, areaSize: number, viewSize: number): [number, number];
-/**
- * @description: 扩散性遍历
- * @param {any[]} array 要遍历的数组
- * @param {(el: any, spreadIndex: number, index: number) => any} callback 回调函数，接收当前元素、扩散性下标、迭代下标作为参数，
- *  如果返回true，则中止遍历
- * @param {number} currIndex 遍历开始的下标
- * @param {number} direction 开始遍历的方向
- * @return {number} 扩散性下标、或开始下标
- */
-export declare function spreadEach(array: any[], callback: (el: any, spreadIndex: number, index: number) => any, startIndex?: number, direction?: number): number;
-/**
- * @description: 深度克隆对象，仅克隆数组和无格式对象，其他类型会被直接返回
- * @param {any} target
- * @return {any}
- */
-export declare function deepClone(target: any): any;
-/**
- * @description: 深拷贝其他对象到第一个对象
- * @param args 任意长度参数对象
- * @return 返回第一个参数对象
- */
-export declare function extend(...args: any[]): any;
-/**
- * @description: 判断两数组是否相等，浅比较
- * @param {any[]} arr1
- * @param {any[]} arr2
- * @return {boolean}
- */
-export declare function arrayEqual(arr1: any[], arr2: any[]): boolean;
 /**
  * @description: 判断一个对象是否为看得到的空
  * @param {any} target
@@ -150,77 +47,14 @@ export declare function throttle(func: (...args: any[]) => any, wait: any, optio
  * @return {[number, number]}
  */
 export declare function getPageRange(current: number, pageCount: number, pageItemCount: number): number[];
-interface AnyObject {
-    [p: string]: any;
-}
-export declare function treeToMap(tree: AnyObject[], keyName: string, childrenName: string, parentName: string): {
-    [p: string]: AnyObject;
-};
-/**
- * @description: 打乱数组
- * @param {any[]} arr 要打乱的数组
- * @param {boolean} inPlace 是否改变原数组
- * @return {any[]}
- */
-export declare function shuffle(arr: any[], inPlace?: boolean): any[];
-interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * @description: 根据原始坐标尺寸和缩放后的坐标尺寸算出转换的原点
- * @param {Rect} rect
- * @param {Rect} scaleRect
- * @return {[number, number]}
- */
-export declare function getTransformOrigin(rect: Rect, scaleRect: Rect): number[];
 /**
  * @description: 将一个可选单位的字符串或数值拆分为数值和单位组成的数组
  * @param {number | string} target
  * @return {[number, string]}
  */
 export declare function splitUnit(target: number | string): [number, string];
-/**
- * @description: 链式获取对象值
- * @param object
- * @param chain 通过点分割的字符串或者字符串数组
- */
-export declare function chainGet(object: any, chain?: string | string[]): any;
-/**
- * @description: 链式设置对象值
- * @param object
- * @param chain 通过点分割的字符串或者字符串数组
- * @param value 要设置的值
- */
-export declare function chainSet(object: any, chain: string | string[], value: any): void;
-/**
- * @description: 移动数组中的元素
- * @param array
- * @param fromIndex
- * @param toIndex
- * @return 移动后的新数组
- */
-export declare function arrayMove(array: any[], fromIndex: number, toIndex: number): any[];
-export type StyleProp = string | Record<any, any> | null | undefined | false | StyleProp[];
-export declare function stringifyStyle(...args: StyleProp[]): string;
-export type ClassProp = string | number | null | undefined | Record<string, any> | ClassProp[];
-export declare function classNames(...args: ClassProp[]): string;
 export declare const noop: () => void;
-export declare function nestedToMulti(nested: any[], values: (number | string)[], fieldKeys: {
-    value: string;
-    children: string;
-}): any[];
-export declare function random(min: number, max: number): number;
-export declare function addSeparator(num: number | string, separator?: string, digit?: number): string;
-export interface Coord {
-    x: number;
-    y: number;
-}
-export declare function getDistanceBetweenTwoPoints(c1: Coord, c2: Coord): number;
 export declare function getMayPrimitiveOption(option: string | number | boolean | {
     [key: PropertyKey]: any;
 }, key: string): any;
 export declare function sleep(time: number): Promise<unknown>;
-export {};