@vope/utils 1.0.2 → 1.1.0

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,45 @@ 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.connectURLParams = exports.joinURLs = exports.Union = exports.deconPowersSum = exports.once = exports.MemoryPower = exports.MemoryList = exports.MemoryBasic = exports.isNull = exports.isEmpty = exports.isClass = 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 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 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, "joinURLs", { 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; } });

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

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;

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,20 @@
 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 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 Union } from './union';
+export { default as joinURLs } from './url/join';
 export { default as connectURLParams } from './url/params';

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/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

@@ -2,7 +2,7 @@ const re = /(^|[^:/])\/{2,}/g;
 /**
  * 实现多个路径拼接
  */
-export const joinURLs = (...list) => {
+const joinURLs = (...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 joinURLs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -11,16 +11,17 @@
   "module": "./lib/index.js",
   "main": "./cjs/index.js",
   "scripts": {
-    "build": "rimraf types & npm run cjs | npm run esm",
+    "build": "npm run cjs | npm run esm | npm run types",
     "init:build": "npm run devs & npm run trove & npm run test:build",
     "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:build": "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"
   },
@@ -44,10 +45,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,20 @@
 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 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 Union } from './union';
+export { default as joinURLs } from './url/join';
 export { default as connectURLParams } from './url/params';

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>);
+}

package/types/memory/power.d.ts

@@ -0,0 +1,8 @@
+import MemoryBasic from './basic';
+import { Memory } from './type';
+/**
+ * 分类存储(基于2的n次幂之和构建唯一键进行存储)
+ */
+export default class MemoryPower<V, Type extends Memory.Type = Memory.Type> extends MemoryBasic<V, number, Type> {
+    constructor(key: Memory.Pitch<V, Type>);
+}

package/types/memory/type.d.ts

@@ -0,0 +1,11 @@
+import { GetGivenProps } from '@vope/types'
+
+export namespace Memory { 
+  type Type = string | number
+
+  type Pitch<Data, Type> = (
+    Data extends object
+      ? GetGivenProps<Data, Type>
+      : never
+  ) | ((data: Data) => Type)
+}

package/types/once.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 缓存函数返回值
+ * @param callback 运行返回值的函数
+ * @param thisArg 绑定到运行函数的this对象
+ */
+declare const _default: <T extends (...args: any) => any>(func: T, thisArg?: any) => (...list: Parameters<T>) => ReturnType<T>;
+export default _default;

package/types/power/decon.d.ts

@@ -0,0 +1,9 @@
+type Sort = 'asc' | 'desc';
+/**
+ * 解构多个2的正整数幂(两两不相等)之和
+ * @param sum 幂和
+ * @param sort 排序方式(默认降序)
+ * @description sum > 2**53则会因为精度问题计算报错
+ */
+declare const deconPowersSum: (sum: number, sort?: Sort) => number[];
+export default deconPowersSum;

package/types/union.d.ts

@@ -0,0 +1,20 @@
+import { Revise } from '@vope/types';
+type IMap<K extends string, VV extends string, T extends {
+    [key in K]: string;
+}> = {
+    [key in VV]?: T;
+};
+/**
+ * 数据联合(用于需要对加入的数据进行智能提示)
+ */
+export default class Union<K extends string, VV extends string, T extends {
+    [key in K]: string;
+}, L extends VV | never = never> {
+    #private;
+    private key;
+    private formater?;
+    get value(): Required<IMap<K, L, T>>;
+    constructor(key: K, formater?: ((data: T) => T) | undefined);
+    add<V extends Exclude<VV, L>>(data: Revise<T, K, V>): Union<K, VV, T, L | V>;
+}
+export {};

package/types/url/join.d.ts

@@ -1,4 +1,5 @@
 /**
  * 实现多个路径拼接
  */
-export declare const joinURLs: (...list: string[]) => string;
+declare const joinURLs: (...list: string[]) => string;
+export default joinURLs;

package/types/compare/value.d.ts

@@ -1,5 +0,0 @@
-/**
- * 值比较(深度浅比较)
- */
-declare const compareValue: (from: any, to: any) => boolean;
-export default compareValue;