@vope/utils 1.0.2 → 1.2.0

package/lib/compare/{value.js → weak-equal.js}

@@ -1,7 +1,7 @@
 /**
- * 值比较(深度浅比较)
+ * 深度相等性比较(弱比较)
  */
-const compareValue = (from, to) => {
+const deepWeakEqual = (from, to) => {
     if (typeof from !== 'object'
         || from === null
         || typeof to !== 'object'
@@ -11,7 +11,7 @@ const compareValue = (from, to) => {
         if (from.length !== to.length)
             return false;
         return !from.some((t1, index) => {
-            if (!compareValue(t1, to[index])) {
+            if (!deepWeakEqual(t1, to[index])) {
                 return true;
             }
         });
@@ -19,7 +19,7 @@ const compareValue = (from, to) => {
     else {
         const caches = {};
         for (const key in from) {
-            if (!compareValue(from[key], to[key])) {
+            if (!deepWeakEqual(from[key], to[key])) {
                 return false;
             }
             else {
@@ -29,11 +29,11 @@ const compareValue = (from, to) => {
         for (const key in to) {
             if (key in caches)
                 continue;
-            if (!compareValue(from[key], to[key])) {
+            if (!deepWeakEqual(from[key], to[key])) {
                 return false;
             }
         }
     }
     return true;
 };
-export default compareValue;
+export default deepWeakEqual;

package/lib/encoding.js

@@ -0,0 +1,63 @@
+const utf8_first_prefix = /^1{2,}/g;
+const utf8_other_prefix = /^10/;
+var Encodes;
+(function (Encodes) {
+    Encodes["UTF_8"] = "utf-8";
+    Encodes["UTF_16LE"] = "utf-16le";
+    Encodes["UTF_16BE"] = "utf-16be";
+    Encodes["GBK"] = "gbk";
+})(Encodes || (Encodes = {}));
+const defaults = {
+    utf8: [0xef, 0xbb, 0xbf],
+};
+const equal = (uint, list) => {
+    if (uint.length !== list.length)
+        return false;
+    return !uint.some((value, index) => value !== list[index]);
+};
+/**
+ * 根据文件内容判断文件的编码
+ * @param uint 文件内容Uint8Array格式
+ * @param limit 用于约束GBK和utf_8的判定上限
+ */
+const getEncoding = (uint, limit = 1024) => {
+    let encoding;
+    let offset = 0;
+    if (equal(uint.slice(0, 3), defaults.utf8)) {
+        offset = defaults.utf8.length;
+        encoding = Encodes.UTF_8;
+    }
+    else if (equal(uint.slice(0, 2), [0xff, 0xfe])) {
+        encoding = Encodes.UTF_16LE;
+    }
+    else if (equal(uint.slice(0, 2), [0xfe, 0xff])) {
+        encoding = Encodes.UTF_16BE;
+    }
+    else {
+        let isBreak = false;
+        top: for (let i = 0; i < Math.min(uint.length, limit); i++) {
+            const data = uint[i];
+            if (data < 128)
+                continue;
+            const match = data.toString(2).match(utf8_first_prefix);
+            if (match) {
+                for (let m = 0; m < match[0].length - 1; m++) {
+                    const target = uint[++i];
+                    if (target == void 0 || !utf8_other_prefix.test(target.toString(2))) {
+                        encoding = Encodes.GBK;
+                        isBreak = true;
+                        break top;
+                    }
+                }
+            }
+            else {
+                encoding = Encodes.GBK;
+                isBreak = true;
+                break;
+            }
+        }
+        isBreak || (encoding = Encodes.UTF_8);
+    }
+    return { encoding, offset };
+};
+export default getEncoding;

package/lib/index.js

@@ -1,10 +1,24 @@
 export { apiPost, apiGet } from './api';
-export { default as compareValue } from './compare/value';
+export { default as clamp } from './clamp';
+export { default as classnames } from './classnames';
+export { default as compareVersion } from './compare/version';
+export { default as deepWeakEqual } from './compare/weak-equal';
 export { default as hash8json } from './convert/json';
 export { default as hash8object } from './convert/object';
 export { default as hash8strings } from './convert/strings';
-export { isClass } from './is/class';
+export { default as getEncoding } from './encoding';
+export { default as inputRegex } from './input-regex';
+export { default as isClass } from './is/class';
 export { default as isEmpty } from './is/empty';
 export { default as isNull } from './is/null';
-export { joinURLs } from './url/join';
+export { default as MemoryBasic } from './memory/basic';
+export { default as MemoryList } from './memory/list';
+export { default as MemoryPower } from './memory/power';
+export { default as once } from './once';
+export { default as deconPowersSum } from './power/decon';
+export { default as rotateAngle } from './rotate/angle';
+export { default as rotateRad } from './rotate/rad';
+export { default as Union } from './union';
+export { default as joinPaths } from './url/join';
 export { default as connectURLParams } from './url/params';
+export { default as wait } from './wait';

package/lib/input-regex.js

@@ -0,0 +1,8 @@
+const RE_REGEX = /[$()*+.[?\\^{|]/g;
+const RE_STRING = /[$()*+.[?\\^{|-]/g;
+function inputRegex(text, flags) {
+    return flags === false
+        ? text.replace(RE_STRING, ($0) => '\\' + $0)
+        : new RegExp(text.replace(RE_REGEX, ($0) => '\\' + $0), flags);
+}
+export default inputRegex;

package/lib/is/class.js

@@ -6,7 +6,7 @@ const re_default = /^function\sdefault_\d+\s*\(/;
 /**
  * 检测是否为class
  */
-export const isClass = (value, strict = true) => {
+const isClass = (value, strict = true) => {
     if (typeof value !== 'function')
         return false;
     const proto = value.prototype;
@@ -27,3 +27,4 @@ export const isClass = (value, strict = true) => {
     }
     return false;
 };
+export default isClass;

package/lib/memory/basic.js

@@ -0,0 +1,142 @@
+import hash8strings from '../convert/strings';
+/**
+ * 分类存储(通过继承，可用于拓展存储方式)
+ */
+export default class MemoryBasic {
+    key;
+    #mount;
+    #reflex;
+    list = [];
+    memorys = new Map();
+    /**
+     * 返回存储长度
+     */
+    get size() {
+        return this.list.length;
+    }
+    /**
+     * @param key 用于对数据进行分类的key
+     * @param config
+     */
+    constructor(key, config) {
+        this.key = key;
+        this.#mount = config.mount;
+        this.#reflex = config.reflex;
+    }
+    getType(data) {
+        const { key } = this;
+        return typeof key === 'function' ? key(data) : data[key];
+    }
+    push(...list) {
+        const { memorys } = this;
+        list.forEach((data) => {
+            const type = this.getType(data);
+            const memory = memorys.get(type);
+            const index = this.list.push(data) - 1;
+            const result = this.#mount(index, memory);
+            memory === result || memorys.set(type, result);
+        });
+        return this;
+    }
+    /**
+     * 遍历所有存储数据(按入栈顺序)
+     */
+    forEach(callback) {
+        this.list.forEach(callback);
+        return this;
+    }
+    /**
+     * 遍历所有存储类型
+     */
+    forType(callback) {
+        const { memorys, list } = this;
+        for (const [type, memory] of memorys) {
+            const caches = this.#reflex(memory).map((index) => list[index]);
+            callback(caches, type);
+        }
+        return this;
+    }
+    /**
+     * 检测存储是否包含某种类型
+     */
+    includes(type) {
+        return type in this.memorys;
+    }
+    /**
+     * 获取指定类型存储数据
+     */
+    get(type) {
+        const memory = this.memorys.get(type);
+        return memory === void 0
+            ? null
+            : this.#reflex(memory).map((count) => this.list[count]);
+    }
+    /**
+     * 删除指定存储数据
+     */
+    delete(data) {
+        const { memorys, list } = this;
+        let index = -1;
+        if (!list.some((value, i) => {
+            if (data === value) {
+                index = i;
+                list.splice(index, 1);
+                const type = this.getType(value);
+                const memory = this.#reflex(memorys.get(type));
+                if (memory.length === 1) {
+                    memorys.delete(type);
+                }
+                else {
+                    memory.some((count, j) => {
+                        if (count === i) {
+                            memory.splice(j, 1);
+                            return true;
+                        }
+                    });
+                }
+                return true;
+            }
+        }))
+            return this;
+        for (const [type, target] of memorys) {
+            const memory = this.#reflex(target);
+            memory.forEach((value, index) => {
+                if (value >= index) {
+                    memory[index] = value - 1;
+                }
+            });
+            if (memory !== target) {
+                let reactor;
+                memory.forEach((count) => {
+                    reactor = this.#mount(count, reactor);
+                });
+                memorys.set(type, reactor);
+            }
+        }
+        return this;
+    }
+    /**
+     * 删除指定类型存储数据
+     */
+    deleteType(type) {
+        const { memorys, list } = this;
+        if (!memorys.has(type))
+            return this;
+        const local = hash8strings(this.#reflex(memorys.get(type)));
+        const Memory = this.constructor;
+        const imitator = new Memory(this.key);
+        list.forEach((data, index) => {
+            index in local || imitator.push(data);
+        });
+        this.list = imitator.list;
+        this.memorys = imitator.memorys;
+        return this;
+    }
+    /**
+     * 清理存储
+     */
+    clear() {
+        this.list = [];
+        this.memorys.clear();
+    }
+}

package/lib/memory/list.js

@@ -0,0 +1,14 @@
+import MemoryBasic from './basic';
+/**
+ * 分类存储(基于普通的键值存储)
+ */
+export default class MemoryList extends MemoryBasic {
+    constructor(key) {
+        super(key, {
+            mount: (index, reactor) => reactor
+                ? (reactor.push(index), reactor)
+                : [index],
+            reflex: (reactor) => reactor,
+        });
+    }
+}

package/lib/memory/power.js

@@ -0,0 +1,13 @@
+import deconPowersSum from '../power/decon';
+import MemoryBasic from './basic';
+/**
+ * 分类存储(基于2的n次幂之和构建唯一键进行存储)
+ */
+export default class MemoryPower extends MemoryBasic {
+    constructor(key) {
+        super(key, {
+            mount: (index, reactor) => (reactor || 0) + 2 ** index,
+            reflex: (reactor) => deconPowersSum(reactor, 'asc'),
+        });
+    }
+}

package/lib/once.js

@@ -0,0 +1,13 @@
+/**
+ * 缓存函数返回值
+ * @param callback 运行返回值的函数
+ * @param thisArg 绑定到运行函数的this对象
+ */
+export default (func, thisArg) => {
+    let local;
+    let inited = false;
+    return (...list) => inited
+        ? local
+        : (inited = true,
+            local = func.apply(thisArg, list));
+};

package/lib/power/decon.js

@@ -0,0 +1,29 @@
+const ERROR_MESSAGE = {
+    INT: '参数必须是整数',
+    MIN: '多个2的正整数幂(两两不相等)之和必定大于等于1',
+};
+/**
+ * 解构多个2的正整数幂(两两不相等)之和
+ * @param sum 幂和
+ * @param sort 排序方式(默认降序)
+ * @description sum > 2**53则会因为精度问题计算报错
+ */
+const deconPowersSum = (sum, sort) => {
+    if (sum < 1) {
+        throw new Error(ERROR_MESSAGE.MIN);
+    }
+    else if (sum !== Math.floor(sum)) {
+        throw new Error(ERROR_MESSAGE.INT);
+    }
+    const list = [];
+    let cache = sum;
+    while (cache) {
+        const power = Math.log2(cache) ^ 0;
+        list.push(power);
+        cache -= Math.pow(2, power);
+    }
+    return sort === 'asc'
+        ? list.reverse()
+        : list;
+};
+export default deconPowersSum;

package/lib/rotate/angle.js

@@ -0,0 +1,9 @@
+import rotateRad from './rad';
+/**
+ * 返回点被旋转指定角度后新的位置
+ * @param from 旋转点
+ * @param angle 旋转角度
+ * @param visit 旋转原点
+ */
+const rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
+export default rotateAngle;

package/lib/rotate/rad.js

@@ -0,0 +1,15 @@
+/**
+ * 返回点被旋转指定弧度后新的位置
+ * @param from 旋转点
+ * @param rad 旋转弧度
+ * @param visit 旋转原点
+ */
+const rotateRad = (from, rad, visit = [0, 0]) => {
+    const x = from[0] - visit[0];
+    const y = from[1] - visit[1];
+    return [
+        x * Math.cos(rad) + y * Math.sin(rad) + visit[0],
+        y * Math.cos(rad) - x * Math.sin(rad) + visit[1],
+    ];
+};
+export default rotateRad;

package/lib/union.js

@@ -0,0 +1,22 @@
+/**
+ * 数据联合(用于需要对加入的数据进行智能提示)
+ */
+export default class Union {
+    key;
+    formater;
+    #map = {};
+    get value() {
+        return this.#map;
+    }
+    constructor(key, formater) {
+        this.key = key;
+        this.formater = formater;
+    }
+    add(data) {
+        const { formater } = this;
+        this.#map[data[this.key]] = formater
+            ? formater(data)
+            : data;
+        return this;
+    }
+}

package/lib/url/join.js

@@ -1,8 +1,8 @@
-const re = /(^|[^:/])\/{2,}/g;
+const re = /([^:])\/{2,}/g;
 /**
  * 实现多个路径拼接
  */
-export const joinURLs = (...list) => {
+const joinPaths = (...list) => {
     const { length } = list;
     if (length === 0)
         return '';
@@ -10,3 +10,4 @@ export const joinURLs = (...list) => {
         ? list[0]
         : list.join('/').replace(re, ($0, $1) => `${$1}/`);
 };
+export default joinPaths;

package/lib/wait.js

@@ -0,0 +1,4 @@
+/**
+ * 等待
+ */
+export default (delay = 0) => new Promise((resolve) => window.setTimeout(resolve, delay));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -11,18 +11,16 @@
   "module": "./lib/index.js",
   "main": "./cjs/index.js",
   "scripts": {
-    "build": "rimraf types & npm run cjs | npm run esm",
-    "init:build": "npm run devs & npm run trove & npm run test:build",
+    "build": "npm run cjs | npm run esm | npm run types",
     "cjs": "rimraf cjs & npx tsc -p ./tsconfig.cjs.json",
     "esm": "rimraf lib & npx tsc -p ./tsconfig.esm.json",
+    "types": "rimraf types & npx tsc -p ./tsconfig.types.json & node ./__devs/type.cjs",
     "trove": "node ./__devs/trove.cjs",
     "trove:build": "npm run devs & npm run trove",
     "devs": "rimraf __devs & npx tsc -p ./tsconfig.devs.json",
-    "test": "mocha __tests/**/*.js",
-    "test:dev": "npm run test:build & npm run test",
-    "test:build": "rimraf __tests & rimraf lib  & node ./__devs/test.cjs",
-    "test:all": "npm run devs & npm run test:build & npm run test",
-    "prepublishOnly": "npm run devs & npm run trove & npm run build"
+    "test": "node ./__devs/test.cjs & mocha __tests/**/*.js",
+    "test:build": "npm run devs & npm run trove & npm run test",
+    "prepublishOnly": "npm run devs & npm run trove & npm run test & npm run build"
   },
   "exports": {
     ".": {
@@ -44,10 +42,11 @@
     "@types/babel__traverse": "^7.20.1",
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.4.5",
-    "@vope/types": "^1.0.0",
+    "@vope/types": "^1.0.2",
+    "iconv-lite": "^0.6.3",
     "mocha": "^10.2.0",
     "rimraf": "^5.0.1",
-    "rollup": "^3.27.1",
+    "rollup": "^3.28.1",
     "tslib": "^2.6.1",
     "typescript": "^5.1.6"
   },

package/types/clamp.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 获取中间数
+ */
+declare const _default: (value: number, min: number, max: number) => number;
+export default _default;

package/types/classnames.d.ts

@@ -0,0 +1,7 @@
+type Base = string | undefined | null;
+type Item = Base | Base[] | Record<string, boolean>;
+/**
+ * 拼接多个class
+ */
+declare const _default: (...list: Item[]) => string;
+export default _default;

package/types/compare/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 版本号大小比较
+ * @description from < to = 1，from === to = 0，from > to = -1
+ */
+declare const compareVersion: (from: string, to: string) => 0 | 1 | -1;
+export default compareVersion;

package/types/compare/weak-equal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 深度相等性比较(弱比较)
+ */
+declare const deepWeakEqual: (from: any, to: any) => boolean;
+export default deepWeakEqual;

package/types/encoding.d.ts

@@ -0,0 +1,16 @@
+declare enum Encodes {
+    UTF_8 = "utf-8",
+    UTF_16LE = "utf-16le",
+    UTF_16BE = "utf-16be",
+    GBK = "gbk"
+}
+/**
+ * 根据文件内容判断文件的编码
+ * @param uint 文件内容Uint8Array格式
+ * @param limit 用于约束GBK和utf_8的判定上限
+ */
+declare const getEncoding: (uint: Uint8Array, limit?: number) => {
+    encoding: Encodes;
+    offset: number;
+};
+export default getEncoding;

package/types/index.d.ts

@@ -1,10 +1,24 @@
 export { apiPost, apiGet } from './api';
-export { default as compareValue } from './compare/value';
+export { default as clamp } from './clamp';
+export { default as classnames } from './classnames';
+export { default as compareVersion } from './compare/version';
+export { default as deepWeakEqual } from './compare/weak-equal';
 export { default as hash8json } from './convert/json';
 export { default as hash8object } from './convert/object';
 export { default as hash8strings } from './convert/strings';
-export { isClass } from './is/class';
+export { default as getEncoding } from './encoding';
+export { default as inputRegex } from './input-regex';
+export { default as isClass } from './is/class';
 export { default as isEmpty } from './is/empty';
 export { default as isNull } from './is/null';
-export { joinURLs } from './url/join';
+export { default as MemoryBasic } from './memory/basic';
+export { default as MemoryList } from './memory/list';
+export { default as MemoryPower } from './memory/power';
+export { default as once } from './once';
+export { default as deconPowersSum } from './power/decon';
+export { default as rotateAngle } from './rotate/angle';
+export { default as rotateRad } from './rotate/rad';
+export { default as Union } from './union';
+export { default as joinPaths } from './url/join';
 export { default as connectURLParams } from './url/params';
+export { default as wait } from './wait';

package/types/input-regex.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 处理输入文本中的特殊字符，用于转换正则表达式
+ * @param text
+ * @param flags 表示输出正则表达式
+ */
+declare function inputRegex(text: string, flags?: string): RegExp;
+/**
+ * 处理输入文本中的特殊字符，用于转换正则表达式
+ * @param text
+ * @param flags 表示输出字符串，该字符串将作为正则表达式的一部分
+ */
+declare function inputRegex(text: string, flags: false): string;
+export default inputRegex;

package/types/is/class.d.ts

@@ -1,4 +1,5 @@
 /**
  * 检测是否为class
  */
-export declare const isClass: (value: any, strict?: boolean) => value is new (...args: any) => any;
+declare const isClass: (value: any, strict?: boolean) => value is new (...args: any) => any;
+export default isClass;

package/types/memory/basic.d.ts

@@ -0,0 +1,63 @@
+import { Memory } from './type';
+interface Config<Reactor> {
+    /**
+     * 定义数据如何挂载到存储中
+     * @param index 当前存入数据对应的角标
+     * @param reactor 当前存入数据对应存储单元
+     */
+    mount(index: number, reactor?: Reactor): Reactor;
+    /**
+     * 定义存储单元和存储关系
+     * @param reactor 存储单元
+     */
+    reflex(reactor: Reactor): number[];
+}
+/**
+ * 分类存储(通过继承，可用于拓展存储方式)
+ */
+export default class MemoryBasic<V, Reactor, Type extends Memory.Type> {
+    #private;
+    protected key: Memory.Pitch<V, Type>;
+    protected list: V[];
+    protected memorys: Map<Type, Reactor>;
+    /**
+     * 返回存储长度
+     */
+    get size(): number;
+    /**
+     * @param key 用于对数据进行分类的key
+     * @param config
+     */
+    constructor(key: Memory.Pitch<V, Type>, config: Config<Reactor>);
+    protected getType(data: V): Type;
+    push(...list: V[]): this;
+    /**
+     * 遍历所有存储数据(按入栈顺序)
+     */
+    forEach(callback: (data: V, index: number) => void): this;
+    /**
+     * 遍历所有存储类型
+     */
+    forType(callback: (data: V[], type: Type) => void): this;
+    /**
+     * 检测存储是否包含某种类型
+     */
+    includes(type: Type): boolean;
+    /**
+     * 获取指定类型存储数据
+     */
+    get(type: Type): V[] | null;
+    /**
+     * 删除指定存储数据
+     */
+    delete(data: V): this;
+    /**
+     * 删除指定类型存储数据
+     */
+    deleteType(type: Type): this;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}
+export {};

package/types/memory/list.d.ts

@@ -0,0 +1,8 @@
+import MemoryBasic from './basic';
+import { Memory } from './type';
+/**
+ * 分类存储(基于普通的键值存储)
+ */
+export default class MemoryList<V, Type extends Memory.Type = Memory.Type> extends MemoryBasic<V, number[], Type> {
+    constructor(key: Memory.Pitch<V, Type>);
+}