sard-uniapp 1.19.5 → 1.20.1

package/utils/geometry.js

@@ -1,33 +1,29 @@
 /**
-```
-                      page
-                     ╱
-    ╭───────────────╮    viewport
-  ╭─│─ ─ ─ ─ ─ ─ ─ ─│─╮ ╱
-  │ │ ╭───────────╮ │ │
-  │ │ │  element  │ │ │
-  │ │ ╰───────────╯ │ │
-  ╰─│─ ─ ─ ─ ─ ─ ─ ─│─╯
-    │               │
-    │               │
-    ╰───────────────╯
-```
-
-# 参数
-- viewportHeight: viewport 高度
-- viewportScrollTop: viewport 垂直滚动值
-- elementHeight: element 高度
-- elementOffsetTop: element 距离页面顶部距离
-
-# 选项
-- position: element 在视窗中的位置(start, center, end, nearest)
-- startOffset: element 距离视窗顶部的偏移量
-- endOffset: element 距离视窗底部的偏移量
-
-# 结果值
-- viewportScrollTop: viewport 新的垂直滚动值
-
-*/
+ * 根据最后位置计算 page 滚动到顶部的值。
+ *
+ * 也可计算水平方向的滚动值。
+ *
+ *                      page
+ *                     ╱
+ *    ╭───────────────╮    viewport
+ *  ╭─│─ ─ ─ ─ ─ ─ ─ ─│─╮ ╱
+ *  │ │ ╭───────────╮ │ │
+ *  │ │ │  element  │ │ │
+ *  │ │ ╰───────────╯ │ │
+ *  ╰─│─ ─ ─ ─ ─ ─ ─ ─│─╯
+ *    │               │
+ *    │               │
+ *    ╰───────────────╯
+ *
+ * @param {number} viewportHeight viewport 高度
+ * @param {number} viewportScrollTop viewport 垂直滚动值
+ * @param {number} elementHeight element 高度
+ * @param {number} elementOffsetTop element 距离页面顶部距离
+ * @param {string} options.position element 在 viewport 中的位置，可选：'start' | 'center' | 'end' | 'nearest'
+ * @param {number} options.startOffset element 距离视窗顶部的偏移量
+ * @param {number} options.endOffset element 距离视窗底部的偏移量
+ * @return {number} viewport 新的垂直滚动值
+ */
 export function getScrollIntoViewValue(viewportHeight, viewportScrollTop, elementHeight, elementOffsetTop, options = {}) {
     const { startOffset = 0, endOffset = 0 } = options;
     let position = options.position || 'nearest';
@@ -68,7 +64,12 @@ export function getScrollIntoViewValue(viewportHeight, viewportScrollTop, elemen
     return nextScrollTop;
 }
 /**
- * @description: 匹配元素列表中第一个位于滚动盒子可视区域的元素
+ * 匹配元素列表中第一个位于滚动盒子可视区域的元素
+ *
+ * @param {array} rects NodeRect 类型数组
+ * @param {function} callback 匹配成功时调用，会接收匹配的元素的下标
+ * @param {number} options.offset 偏移量
+ * @param {number} options.errorValue 容错值
  */
 export async function matchScrollVisible(rects, callback, options = {}) {
     const { offset: optionOffset = 0, errorValue = 3 } = options;
@@ -92,6 +93,9 @@ export async function matchScrollVisible(rects, callback, options = {}) {
         }
     }
 }
+/**
+ * 保持纵横比缩放图片，只保证图片的短边能完全显示出来。也就是说，图片通常只在水平或垂直方向是完整的，另一个方向将会发生截取。
+ */
 export function getAspectFillSize(origWidth, origHeight, containerWidth, containerHeight) {
     let width = 0;
     let height = 0;
@@ -107,6 +111,9 @@ export function getAspectFillSize(origWidth, origHeight, containerWidth, contain
     }
     return [width, height];
 }
+/**
+ * 保持纵横比缩放图片，使图片的长边能完全显示出来。也就是说，可以完整地将图片显示出来。
+ */
 export function getAspectFitSize(origWidth, origHeight, containerWidth, containerHeight) {
     let width = 0;
     let height = 0;
@@ -122,6 +129,25 @@ export function getAspectFitSize(origWidth, origHeight, containerWidth, containe
     }
     return [width, height];
 }
+/**
+ * 获取两点间的距离
+ */
 export function getTwoPointsDistance(p1, p2) {
     return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
 }
+/**
+ * @description: 根据原始坐标尺寸和缩放后的坐标尺寸算出转换的原点
+ * @param {Rect} rect
+ * @param {Rect} scaleRect
+ * @return {[number, number]}
+ */
+export function getTransformOrigin(rect, scaleRect) {
+    const ratio = scaleRect.width / rect.width;
+    const originX = (rect.x + rect.width / 2 - scaleRect.x - scaleRect.width / 2) /
+        (ratio - 1) +
+        rect.width / 2;
+    const originY = (rect.y + rect.height / 2 - scaleRect.y - scaleRect.height / 2) /
+        (ratio - 1) +
+        rect.height / 2;
+    return [originX, originY];
+}

package/utils/index.d.ts

@@ -1,5 +1,4 @@
 export * from './bem';
-export * from './case';
 export * from './date';
 export * from './dom';
 export * from './file';
@@ -9,5 +8,13 @@ export * from './lwa.slim';
 export * from './qrcode';
 export * from './system';
 export * from './object';
+export * from './array';
+export * from './string';
+export * from './number';
 export * from './geometry';
+export * from './physics';
 export * from './inertialAnimate';
+export * from './persist';
+export * from './request';
+export * from './url-query';
+export * from './router';

package/utils/index.js

@@ -1,5 +1,4 @@
 export * from './bem';
-export * from './case';
 export * from './date';
 export * from './dom';
 export * from './file';
@@ -9,5 +8,13 @@ export * from './lwa.slim';
 export * from './qrcode';
 export * from './system';
 export * from './object';
+export * from './array';
+export * from './string';
+export * from './number';
 export * from './geometry';
+export * from './physics';
 export * from './inertialAnimate';
+export * from './persist';
+export * from './request';
+export * from './url-query';
+export * from './router';

package/utils/is.d.ts

@@ -4,6 +4,12 @@
  * @return {boolean}
  */
 export declare function isPlainObject(target: any): target is Record<PropertyKey, any>;
+/**
+ * @description: 判断是否为空数组
+ * @param {any} target
+ * @return {boolean}
+ */
+export declare function isEmptyArray(target: any): boolean;
 /**
  * @description: 判断是否为对象
  * @param {any} target
@@ -54,3 +60,9 @@ export declare function isNullish(target: any): target is null | undefined;
  * @return {boolean}
  */
 export declare function isPrimitive(target: any): target is string | number | boolean;
+/**
+ * @description: 判断是否为日期类型
+ * @param {any} target
+ * @return {boolean}
+ */
+export declare function isDate(target: any): target is Date;

package/utils/is.js

@@ -6,6 +6,14 @@
 export function isPlainObject(target) {
     return Object.prototype.toString.call(target) === '[object Object]';
 }
+/**
+ * @description: 判断是否为空数组
+ * @param {any} target
+ * @return {boolean}
+ */
+export function isEmptyArray(target) {
+    return Array.isArray(target) && target.length === 0;
+}
 /**
  * @description: 判断是否为对象
  * @param {any} target
@@ -70,3 +78,11 @@ export function isNullish(target) {
 export function isPrimitive(target) {
     return isString(target) || isNumber(target) || isBoolean(target);
 }
+/**
+ * @description: 判断是否为日期类型
+ * @param {any} target
+ * @return {boolean}
+ */
+export function isDate(target) {
+    return target instanceof Date;
+}

package/utils/number.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 限定数值范围
+ */
+export declare function clamp(n: number, min: number, max: number): number;
+/**
+ * 把一个数四舍五入到指定位数小数。
+ */
+export declare function round(n: number, precision?: number): number;
+/**
+ * 获取小数位数
+ */
+export declare function getDecimalsLength(n: number | string): number;
+/**
+ * 把一个数舍入到指定数的倍数
+ */
+export declare function mround(n: number, m: number): number;
+/**
+ * 生成两数间的一个随机整数
+ */
+export declare function random(min: number, max: number): number;
+/**
+ * 判断一个数是否在指定范围内。
+ */
+export declare function inRange(n: number, min: number, max: number): boolean;

package/utils/number.js

@@ -0,0 +1,37 @@
+/**
+ * 限定数值范围
+ */
+export function clamp(n, min, max) {
+    return n < min ? min : n > max ? max : n;
+}
+/**
+ * 把一个数四舍五入到指定位数小数。
+ */
+export function round(n, precision = 0) {
+    return Math.round(+(n + 'e' + precision)) / 10 ** precision;
+}
+/**
+ * 获取小数位数
+ */
+export function getDecimalsLength(n) {
+    n = n.toString().split('.')[1];
+    return n ? n.length : 0;
+}
+/**
+ * 把一个数舍入到指定数的倍数
+ */
+export function mround(n, m) {
+    return round(n - (n % m) + Math.round((n % m) / m) * m, getDecimalsLength(m));
+}
+/**
+ * 生成两数间的一个随机整数
+ */
+export function random(min, max) {
+    return min + Math.floor(Math.random() * (max - min + 1));
+}
+/**
+ * 判断一个数是否在指定范围内。
+ */
+export function inRange(n, min, max) {
+    return n > min && n < max;
+}

package/utils/object.d.ts

@@ -1,4 +1,33 @@
+import { AnyObject } from './common';
 /**
  * 此方法创建一个对象，该对象由自己不可省略的属性组成。
  */
 export declare function omit<T extends object, U extends keyof T>(object: T, paths: U[]): Omit<T, U>;
+/**
+ * 深度克隆对象，仅克隆数组和无格式对象，其他类型会被直接返回
+ */
+export declare function deepClone(target: any): any;
+/**
+ * 深拷贝其他对象到第一个对象
+ */
+export declare function extend(...args: any[]): any;
+export declare function treeToMap(tree: AnyObject[], keyName: string, childrenName: string, parentName: string): {
+    [p: string]: AnyObject;
+};
+/**
+ * @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;
+export declare function nestedToMulti(nested: any[], values: (number | string)[], fieldKeys: {
+    value: string;
+    children: string;
+}): any[];

package/utils/object.js

@@ -1,3 +1,4 @@
+import { isPlainObject } from './is';
 /**
  * 此方法创建一个对象，该对象由自己不可省略的属性组成。
  */
@@ -11,3 +12,141 @@ export function omit(object, paths) {
     });
     return newObj;
 }
+/**
+ * 深度克隆对象，仅克隆数组和无格式对象，其他类型会被直接返回
+ */
+export function deepClone(target) {
+    if (Array.isArray(target)) {
+        return target.map((item) => {
+            return deepClone(item);
+        });
+    }
+    if (isPlainObject(target)) {
+        const obj = {};
+        Object.keys(target).forEach((k) => {
+            obj[k] = deepClone(target[k]);
+        });
+        return obj;
+    }
+    return target;
+}
+/**
+ * 深拷贝其他对象到第一个对象
+ */
+export function extend(...args) {
+    const target = args[0], l = args.length;
+    let i = 1, options, name, src, copy, copyIsArray, clone;
+    for (; i < l; i++) {
+        options = args[i];
+        if (options !== null && options !== undefined) {
+            for (name in options) {
+                src = target[name];
+                copy = options[name];
+                // 防止有环
+                if (target === copy) {
+                    continue;
+                }
+                // 深复制
+                if (copy &&
+                    (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+                    if (copyIsArray) {
+                        copyIsArray = false;
+                        clone = src && Array.isArray(src) ? src : [];
+                    }
+                    else {
+                        clone = isPlainObject(src) ? src : {};
+                    }
+                    // 只克隆对象，不移动
+                    target[name] = extend(clone, copy);
+                    // 不添加未定义的值
+                }
+                else if (copy !== undefined) {
+                    target[name] = copy;
+                }
+            }
+        }
+    }
+    return target;
+}
+export function treeToMap(tree, keyName, childrenName, parentName) {
+    const map = {};
+    function recurse(children, parent) {
+        children.forEach((node) => {
+            map[node[keyName]] = node;
+            node[parentName] = parent;
+            if (Array.isArray(node[childrenName])) {
+                recurse(node[childrenName], node);
+            }
+        });
+    }
+    recurse(tree, null);
+    return map;
+}
+/**
+ * @description: 链式获取对象值
+ * @param object
+ * @param chain 通过点分割的字符串或者字符串数组
+ */
+export function chainGet(object, chain) {
+    let target = object;
+    if (chain) {
+        chain = typeof chain === 'string' ? chain.split('.') : chain;
+        for (const key of chain) {
+            if (target && typeof target === 'object') {
+                target = target[key];
+            }
+            else {
+                return target;
+            }
+        }
+    }
+    return target;
+}
+/**
+ * @description: 链式设置对象值
+ * @param object
+ * @param chain 通过点分割的字符串或者字符串数组
+ * @param value 要设置的值
+ */
+export function chainSet(object, chain, value) {
+    let target = object;
+    chain = typeof chain === 'string' ? chain.split('.') : chain;
+    if (chain.length === 0) {
+        return;
+    }
+    for (let i = 0, l = chain.length; i < l; i++) {
+        if (target && typeof target === 'object') {
+            const key = chain[i];
+            if (i === l - 1) {
+                target[key] = value;
+                return;
+            }
+            else {
+                target = target[key];
+            }
+        }
+        else {
+            return;
+        }
+    }
+}
+// 将嵌套数据结构转换为多维数组
+export function nestedToMulti(nested, values, fieldKeys) {
+    const columns = [];
+    function recurse(list, index = 0) {
+        columns.push(list);
+        const selectedValue = values[index];
+        let selectedOption = list.find((option) => option[fieldKeys.value] === selectedValue);
+        if (!selectedOption) {
+            selectedOption = list[0];
+        }
+        if (selectedOption) {
+            const nextList = selectedOption[fieldKeys.children];
+            if (Array.isArray(nextList)) {
+                recurse(nextList, ++index);
+            }
+        }
+    }
+    recurse(nested);
+    return columns;
+}

package/utils/persist.d.ts

@@ -0,0 +1,15 @@
+export declare class Persist {
+    name: string;
+    prefix: string;
+    cache: Record<string, {
+        ttl: number;
+        value: any;
+    }>;
+    constructor(name: string);
+    private getCache;
+    private save;
+    get(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    remove(key: string): void;
+    clear(): void;
+}

package/utils/persist.js

@@ -0,0 +1,89 @@
+export class Persist {
+    name;
+    prefix;
+    cache = {};
+    constructor(name) {
+        this.name = name;
+        this.prefix = name + '#';
+        this.cache = this.getCache();
+    }
+    getCache() {
+        const cache = {};
+        const res = uni.getStorageInfoSync();
+        for (let i = 0; i < res.keys.length; i++) {
+            const key = res.keys[i];
+            if (key && key.startsWith(this.prefix)) {
+                const value = uni.getStorageSync(key);
+                if (value) {
+                    try {
+                        const result = JSON.parse(value);
+                        if (result &&
+                            typeof result === 'object' &&
+                            !Array.isArray(result)) {
+                            cache[key] = result;
+                        }
+                    }
+                    catch {
+                        void 0;
+                    }
+                }
+            }
+        }
+        return cache;
+    }
+    save(fullKey) {
+        if (fullKey) {
+            if (fullKey in this.cache) {
+                uni.setStorageSync(fullKey, JSON.stringify(this.cache[fullKey]));
+            }
+            else {
+                uni.removeStorageSync(fullKey);
+            }
+        }
+        else {
+            const res = uni.getStorageInfoSync();
+            for (let i = 0; i < res.keys.length; i++) {
+                const key = res.keys[i];
+                if (key && key.startsWith(this.prefix)) {
+                    if (!(key in this.cache)) {
+                        uni.removeStorageSync(key);
+                        i--;
+                    }
+                }
+            }
+            Object.keys(this.cache).forEach((key) => {
+                uni.setStorageSync(key, JSON.stringify(this.cache[key]));
+            });
+        }
+    }
+    get(key) {
+        const item = this.cache[this.prefix + key];
+        if (item) {
+            if (item.ttl > 0 && item.ttl < Date.now()) {
+                this.remove(key);
+            }
+            else {
+                return item.value;
+            }
+        }
+    }
+    set(key, value, ttl = 0) {
+        const fullKey = this.prefix + key;
+        this.cache[fullKey] = {
+            ttl: ttl > 0 ? ttl * 1000 + Date.now() : 0,
+            value,
+        };
+        this.save(fullKey);
+    }
+    remove(key) {
+        const fullKey = this.prefix + key;
+        if (fullKey in this.cache) {
+            delete this.cache[fullKey];
+            this.save(fullKey);
+        }
+    }
+    clear() {
+        this.cache = {};
+        this.save();
+    }
+}

package/utils/physics.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @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];

package/utils/physics.js

@@ -0,0 +1,66 @@
+import { clamp } from './number';
+/**
+ * @description: 获取阻尼值
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @param {number} damping
+ * @return {number}
+ */
+export function getDampingValue(value, min, max, damping) {
+    if (value < min) {
+        return min + (value - min) * damping;
+    }
+    if (value > max) {
+        return max + (value - max) * damping;
+    }
+    return value;
+}
+/**
+ * @description: 获取矩形阻尼值
+ * @param {number} offset 当前的偏移量
+ * @param {number} areaSize 范围值
+ * @param {number} viewSize 范围内某个视图尺寸值
+ * @param {number} damping 阻尼系数
+ * @return {number}
+ */
+export function getRectDampingValue(offset, areaSize, viewSize, damping) {
+    const diff = areaSize - viewSize;
+    let min, max;
+    if (diff < 0) {
+        min = diff;
+        max = 0;
+    }
+    else {
+        min = 0;
+        max = diff;
+    }
+    return getDampingValue(offset, min, max, damping);
+}
+/**
+ * @description: 获取范围值
+ * @param {number} offset 当前的偏移量
+ * @param {number} areaSize 范围值
+ * @param {number} viewSize 范围内某个视图尺寸值
+ * @return {number}
+ */
+export function getInBoundValue(offset, areaSize, viewSize) {
+    const diff = areaSize - viewSize;
+    const [min, max] = [0, diff].sort((a, b) => a - b);
+    return clamp(offset, min, max);
+}
+/**
+ * @description: 获取溢出值范围
+ * @param {number} overflow 最大溢出值
+ * @param {number} areaSize 范围值
+ * @param {number} viewSize 范围内某个视图尺寸值
+ * @return {*}
+ */
+export function getOverflowRangeInArea(overflow, areaSize, viewSize) {
+    if (areaSize > viewSize) {
+        return [-overflow, areaSize + overflow];
+    }
+    else {
+        return [areaSize - viewSize - overflow, overflow];
+    }
+}