@vope/utils 1.0.2 → 1.2.0

package/README.md

@@ -3,11 +3,6 @@
 发布构建
 ```
 
-### init:build
-```
-发布构建(初次需要先构建基本环境)
-```
-
 ### cjs
 ```
 构建cjs版本

package/cjs/clamp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 获取中间数
+ */
+exports.default = (value, min, max) => {
+    if (min > max) {
+        // js位运算的范围为(-2^32,2^32)，超出会产生溢出
+        const swap = max;
+        max = min;
+        min = swap;
+    }
+    return Math.min(max, Math.max(min, value));
+};

package/cjs/classnames.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const add = (a, b) => a
+    ? a + '\u0020' + b
+    : b;
+/**
+ * 拼接多个class
+ */
+exports.default = (...list) => list.reduce((caches, data) => {
+    if (typeof data === 'string') {
+        data && (caches = add(caches, data));
+    }
+    else if (Array.isArray(data)) {
+        data.forEach((value) => value && (caches = add(caches, value)));
+    }
+    else if (data) {
+        for (const key in data) {
+            key && data[key] && (caches = add(caches, key));
+        }
+    }
+    return caches;
+}, '');

package/cjs/compare/version.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CHAR = '.';
+/**
+ * 版本号大小比较
+ * @description from < to = 1，from === to = 0，from > to = -1
+ */
+const compareVersion = (from, to) => {
+    const froms = from.split(CHAR);
+    const tos = to.split(CHAR);
+    for (let i = 0, max = Math.max(froms.length, tos.length); i < max; i++) {
+        const fromV = +froms[i] || 0;
+        const toV = +tos[i] || 0;
+        if (fromV > toV)
+            return -1;
+        if (fromV < toV)
+            return 1;
+    }
+    return 0;
+};
+exports.default = compareVersion;

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * 值比较(深度浅比较)
+ * 深度相等性比较(弱比较)
  */
-const compareValue = (from, to) => {
+const deepWeakEqual = (from, to) => {
     if (typeof from !== 'object'
         || from === null
         || typeof to !== 'object'
@@ -13,7 +13,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;
             }
         });
@@ -21,7 +21,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 {
@@ -31,11 +31,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;
 };
-exports.default = compareValue;
+exports.default = deepWeakEqual;

package/cjs/encoding.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 };
+};
+exports.default = getEncoding;

package/cjs/index.js

@@ -3,25 +3,53 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.connectURLParams = exports.joinURLs = exports.isNull = exports.isEmpty = exports.isClass = exports.hash8strings = exports.hash8object = exports.hash8json = exports.compareValue = exports.apiGet = exports.apiPost = void 0;
+exports.wait = exports.connectURLParams = exports.joinPaths = exports.Union = exports.rotateRad = exports.rotateAngle = exports.deconPowersSum = exports.once = exports.MemoryPower = exports.MemoryList = exports.MemoryBasic = exports.isNull = exports.isEmpty = exports.isClass = exports.inputRegex = exports.getEncoding = exports.hash8strings = exports.hash8object = exports.hash8json = exports.deepWeakEqual = exports.compareVersion = exports.classnames = exports.clamp = exports.apiGet = exports.apiPost = void 0;
 var api_1 = require("./api");
 Object.defineProperty(exports, "apiPost", { enumerable: true, get: function () { return api_1.apiPost; } });
 Object.defineProperty(exports, "apiGet", { enumerable: true, get: function () { return api_1.apiGet; } });
-var value_1 = require("./compare/value");
-Object.defineProperty(exports, "compareValue", { enumerable: true, get: function () { return __importDefault(value_1).default; } });
+var clamp_1 = require("./clamp");
+Object.defineProperty(exports, "clamp", { enumerable: true, get: function () { return __importDefault(clamp_1).default; } });
+var classnames_1 = require("./classnames");
+Object.defineProperty(exports, "classnames", { enumerable: true, get: function () { return __importDefault(classnames_1).default; } });
+var version_1 = require("./compare/version");
+Object.defineProperty(exports, "compareVersion", { enumerable: true, get: function () { return __importDefault(version_1).default; } });
+var weak_equal_1 = require("./compare/weak-equal");
+Object.defineProperty(exports, "deepWeakEqual", { enumerable: true, get: function () { return __importDefault(weak_equal_1).default; } });
 var json_1 = require("./convert/json");
 Object.defineProperty(exports, "hash8json", { enumerable: true, get: function () { return __importDefault(json_1).default; } });
 var object_1 = require("./convert/object");
 Object.defineProperty(exports, "hash8object", { enumerable: true, get: function () { return __importDefault(object_1).default; } });
 var strings_1 = require("./convert/strings");
 Object.defineProperty(exports, "hash8strings", { enumerable: true, get: function () { return __importDefault(strings_1).default; } });
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "getEncoding", { enumerable: true, get: function () { return __importDefault(encoding_1).default; } });
+var input_regex_1 = require("./input-regex");
+Object.defineProperty(exports, "inputRegex", { enumerable: true, get: function () { return __importDefault(input_regex_1).default; } });
 var class_1 = require("./is/class");
-Object.defineProperty(exports, "isClass", { enumerable: true, get: function () { return class_1.isClass; } });
+Object.defineProperty(exports, "isClass", { enumerable: true, get: function () { return __importDefault(class_1).default; } });
 var empty_1 = require("./is/empty");
 Object.defineProperty(exports, "isEmpty", { enumerable: true, get: function () { return __importDefault(empty_1).default; } });
 var null_1 = require("./is/null");
 Object.defineProperty(exports, "isNull", { enumerable: true, get: function () { return __importDefault(null_1).default; } });
+var basic_1 = require("./memory/basic");
+Object.defineProperty(exports, "MemoryBasic", { enumerable: true, get: function () { return __importDefault(basic_1).default; } });
+var list_1 = require("./memory/list");
+Object.defineProperty(exports, "MemoryList", { enumerable: true, get: function () { return __importDefault(list_1).default; } });
+var power_1 = require("./memory/power");
+Object.defineProperty(exports, "MemoryPower", { enumerable: true, get: function () { return __importDefault(power_1).default; } });
+var once_1 = require("./once");
+Object.defineProperty(exports, "once", { enumerable: true, get: function () { return __importDefault(once_1).default; } });
+var decon_1 = require("./power/decon");
+Object.defineProperty(exports, "deconPowersSum", { enumerable: true, get: function () { return __importDefault(decon_1).default; } });
+var angle_1 = require("./rotate/angle");
+Object.defineProperty(exports, "rotateAngle", { enumerable: true, get: function () { return __importDefault(angle_1).default; } });
+var rad_1 = require("./rotate/rad");
+Object.defineProperty(exports, "rotateRad", { enumerable: true, get: function () { return __importDefault(rad_1).default; } });
+var union_1 = require("./union");
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return __importDefault(union_1).default; } });
 var join_1 = require("./url/join");
-Object.defineProperty(exports, "joinURLs", { enumerable: true, get: function () { return join_1.joinURLs; } });
+Object.defineProperty(exports, "joinPaths", { enumerable: true, get: function () { return __importDefault(join_1).default; } });
 var params_1 = require("./url/params");
 Object.defineProperty(exports, "connectURLParams", { enumerable: true, get: function () { return __importDefault(params_1).default; } });
+var wait_1 = require("./wait");
+Object.defineProperty(exports, "wait", { enumerable: true, get: function () { return __importDefault(wait_1).default; } });

package/cjs/input-regex.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+}
+exports.default = inputRegex;

package/cjs/is/class.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClass = void 0;
 const re_anonymous = /^function\s+\(|^function\s+anonymous\(/;
 const re_function = /^function\s+[A-Z]/;
 const re_this = /\b\(this\b|\bthis[\.\[]\b/;
@@ -30,4 +29,4 @@ const isClass = (value, strict = true) => {
     }
     return false;
 };
-exports.isClass = isClass;
+exports.default = isClass;

package/cjs/memory/basic.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strings_1 = __importDefault(require("../convert/strings"));
+/**
+ * 分类存储(通过继承，可用于拓展存储方式)
+ */
+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 = (0, strings_1.default)(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();
+    }
+}
+exports.default = MemoryBasic;

package/cjs/memory/list.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const basic_1 = __importDefault(require("./basic"));
+/**
+ * 分类存储(基于普通的键值存储)
+ */
+class MemoryList extends basic_1.default {
+    constructor(key) {
+        super(key, {
+            mount: (index, reactor) => reactor
+                ? (reactor.push(index), reactor)
+                : [index],
+            reflex: (reactor) => reactor,
+        });
+    }
+}
+exports.default = MemoryList;

package/cjs/memory/power.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const decon_1 = __importDefault(require("../power/decon"));
+const basic_1 = __importDefault(require("./basic"));
+/**
+ * 分类存储(基于2的n次幂之和构建唯一键进行存储)
+ */
+class MemoryPower extends basic_1.default {
+    constructor(key) {
+        super(key, {
+            mount: (index, reactor) => (reactor || 0) + 2 ** index,
+            reflex: (reactor) => (0, decon_1.default)(reactor, 'asc'),
+        });
+    }
+}
+exports.default = MemoryPower;

package/cjs/once.js

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

package/cjs/power/decon.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+};
+exports.default = deconPowersSum;

package/cjs/rotate/angle.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rad_1 = __importDefault(require("./rad"));
+/**
+ * 返回点被旋转指定角度后新的位置
+ * @param from 旋转点
+ * @param angle 旋转角度
+ * @param visit 旋转原点
+ */
+const rotateAngle = (from, angle, visit) => (0, rad_1.default)(from, angle / 180 * Math.PI, visit);
+exports.default = rotateAngle;

package/cjs/rotate/rad.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 返回点被旋转指定弧度后新的位置
+ * @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],
+    ];
+};
+exports.default = rotateRad;

package/cjs/union.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 数据联合(用于需要对加入的数据进行智能提示)
+ */
+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;
+    }
+}
+exports.default = Union;

package/cjs/url/join.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinURLs = void 0;
-const re = /(^|[^:/])\/{2,}/g;
+const re = /([^:])\/{2,}/g;
 /**
  * 实现多个路径拼接
  */
-const joinURLs = (...list) => {
+const joinPaths = (...list) => {
     const { length } = list;
     if (length === 0)
         return '';
@@ -13,4 +12,4 @@ const joinURLs = (...list) => {
         ? list[0]
         : list.join('/').replace(re, ($0, $1) => `${$1}/`);
 };
-exports.joinURLs = joinURLs;
+exports.default = joinPaths;

package/cjs/wait.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 等待
+ */
+exports.default = (delay = 0) => new Promise((resolve) => window.setTimeout(resolve, delay));

package/lib/clamp.js

@@ -0,0 +1,12 @@
+/**
+ * 获取中间数
+ */
+export default (value, min, max) => {
+    if (min > max) {
+        // js位运算的范围为(-2^32,2^32)，超出会产生溢出
+        const swap = max;
+        max = min;
+        min = swap;
+    }
+    return Math.min(max, Math.max(min, value));
+};

package/lib/classnames.js

@@ -0,0 +1,20 @@
+const add = (a, b) => a
+    ? a + '\u0020' + b
+    : b;
+/**
+ * 拼接多个class
+ */
+export default (...list) => list.reduce((caches, data) => {
+    if (typeof data === 'string') {
+        data && (caches = add(caches, data));
+    }
+    else if (Array.isArray(data)) {
+        data.forEach((value) => value && (caches = add(caches, value)));
+    }
+    else if (data) {
+        for (const key in data) {
+            key && data[key] && (caches = add(caches, key));
+        }
+    }
+    return caches;
+}, '');

package/lib/compare/version.js

@@ -0,0 +1,19 @@
+const CHAR = '.';
+/**
+ * 版本号大小比较
+ * @description from < to = 1，from === to = 0，from > to = -1
+ */
+const compareVersion = (from, to) => {
+    const froms = from.split(CHAR);
+    const tos = to.split(CHAR);
+    for (let i = 0, max = Math.max(froms.length, tos.length); i < max; i++) {
+        const fromV = +froms[i] || 0;
+        const toV = +tos[i] || 0;
+        if (fromV > toV)
+            return -1;
+        if (fromV < toV)
+            return 1;
+    }
+    return 0;
+};
+export default compareVersion;