@pawover/kit 0.0.0-alpha.1

package/dist/utils/array.js

@@ -0,0 +1,196 @@
+import { isArray, isFunction } from "./typeof";
+export function toArray(candidate) {
+    if (candidate === undefined || candidate === false) {
+        return [];
+    }
+    return isArray(candidate) ? candidate : [candidate];
+}
+/**
+ * 获取数组第一项
+ *
+ * @param initialList 初始数组
+ * @param saveValue 安全值
+ */
+export function arrayFirst(initialList, saveValue) {
+    if (!isArray(initialList) || initialList.length === 0) {
+        return saveValue;
+    }
+    return initialList[0];
+}
+/**
+ * 获取数组最后一项
+ *
+ * @param initialList 初始数组
+ * @param saveValue 安全值
+ */
+export function arrayLast(initialList, saveValue) {
+    if (!isArray(initialList) || initialList.length === 0) {
+        return saveValue;
+    }
+    return initialList[initialList.length - 1];
+}
+export function arrayDiff(initialList, diffList, match) {
+    if (!isArray(initialList) && !isArray(diffList)) {
+        return [];
+    }
+    if (!isArray(initialList) || !initialList.length) {
+        return [...diffList];
+    }
+    if (!isArray(diffList) || !diffList.length) {
+        return [...initialList];
+    }
+    if (!isFunction(match)) {
+        return [];
+    }
+    const keys = diffList.reduce((prev, curr) => {
+        prev[match(curr)] = true;
+        return prev;
+    }, {});
+    return initialList.filter((a) => !keys[match(a)]);
+}
+/**
+ * 数组竞争
+ * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+ *
+ * @param initialList 数组
+ * @param match 匹配函数
+ */
+export function arrayCompete(initialList, match) {
+    if (!isArray(initialList) || initialList.length === 0 || !isFunction(match)) {
+        return null;
+    }
+    return initialList.reduce(match);
+}
+/**
+ * 统计数组的项目出现次数
+ * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+ *
+ * @param initialList 初始数组
+ * @param match 标识符匹配函数
+ */
+export function arrayCounting(initialList, match) {
+    if (!isArray(initialList) || !isFunction(match)) {
+        return {};
+    }
+    return initialList.reduce((prev, curr) => {
+        const id = match(curr).toString();
+        prev[id] = (prev[id] ?? 0) + 1;
+        return prev;
+    }, {});
+}
+/**
+ * 数组项替换
+ * - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
+ *
+ * @param initialList 初始数组
+ * @param newItem 替换项
+ * @param match 匹配函数
+ */
+export function arrayReplace(initialList, newItem, match) {
+    if (!initialList) {
+        return [];
+    }
+    if (newItem === undefined || !isFunction(match)) {
+        return [...initialList];
+    }
+    for (let i = 0; i < initialList.length; i++) {
+        const item = initialList[i];
+        if (item !== undefined && match(item, i)) {
+            return [...initialList.slice(0, i), newItem, ...initialList.slice(i + 1, initialList.length)];
+        }
+    }
+    return [...initialList];
+}
+/**
+ * 数组选择
+ * - 一次性应用 `filter` 和 `map` 操作
+ *
+ * @param initialList 初始数组
+ * @param filter filter 函数
+ * @param mapper map 函数
+ */
+export function arrayPick(initialList, filter, mapper) {
+    if (!isArray(initialList)) {
+        return [];
+    }
+    if (!isFunction(filter)) {
+        return initialList;
+    }
+    const hasMapper = isFunction(mapper);
+    return initialList.reduce((prev, curr, index) => {
+        if (!filter(curr, index)) {
+            return prev;
+        }
+        if (hasMapper) {
+            prev.push(mapper(curr, index));
+        }
+        else {
+            prev.push(curr);
+        }
+        return prev;
+    }, []);
+}
+/**
+ * 数组切分
+ * - 将数组以指定的长度切分后，组合在高维数组中
+ *
+ * @param initialList 初始数组
+ * @param size 分割尺寸，默认 `10`
+ */
+export function arraySplit(initialList, size = 10) {
+    if (!isArray(initialList)) {
+        return [];
+    }
+    const count = Math.ceil(initialList.length / size);
+    return Array.from({ length: count })
+        .fill(null)
+        .map((_c, i) => {
+        return initialList.slice(i * size, i * size + size);
+    });
+}
+/**
+ * 数组迭代
+ * - 运行一个函数 n 次以生成一个值，迭代函数将作为还原器运行无数次，然后返回累积值
+ *
+ * @param count 迭代次数
+ * @param iterate 迭代函数
+ * @param initialValue 初始值
+ */
+export function arrayIterate(count, iterate, initialValue) {
+    let result = initialValue;
+    if (isFunction(iterate)) {
+        for (let i = 1; i <= count; i++) {
+            result = iterate(result, i);
+        }
+    }
+    return result;
+}
+/**
+ * 数组合并
+ * - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
+ *
+ * @param initialList 初始数组
+ * @param mergeList 待合并数组
+ * @param match 标识符匹配函数
+ */
+export function arrayMerge(initialList, mergeList, match) {
+    if (!isArray(initialList)) {
+        return [];
+    }
+    if (!isArray(mergeList)) {
+        return initialList;
+    }
+    if (!isFunction(match)) {
+        return initialList;
+    }
+    return initialList.reduce((prev, curr) => {
+        const matched = mergeList.find((list) => match(curr) === match(list));
+        if (matched) {
+            prev.push(matched);
+        }
+        else {
+            prev.push(curr);
+        }
+        return prev;
+    }, []);
+}

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./array";
+export * from "./object";
+export * from "./string";
+export * from "./to";
+export * from "./tree";
+export * from "./typeof";

package/dist/utils/object.js

@@ -0,0 +1,138 @@
+import { isArray, isObject } from "./typeof";
+/**
+ * 返回对象的可枚举属性和方法的名称
+ * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+ *
+ * @param obj 对象
+ * @returns 对象所有可枚举的属性的键名
+ */
+export function objectKeys(obj) {
+    return Object.keys(obj);
+}
+/**
+ * 返回对象的可枚举属性的值数组
+ *
+ * @param obj 对象
+ */
+export function objectValues(obj) {
+    return Object.values(obj);
+}
+/**
+ * 返回对象的可枚举属性的键/值数组
+ *
+ * @param obj 对象
+ */
+export function objectEntries(obj) {
+    return Object.entries(obj);
+}
+/**
+ * 对象反转
+ * - 返回交换了对象的可枚举属性的值/键对象
+ *
+ * @param obj 对象
+ */
+export function objectSwitch(obj) {
+    const result = {};
+    if (!isObject(obj)) {
+        return result;
+    }
+    for (const [k, v] of objectEntries(obj)) {
+        result[v] = k;
+    }
+    return result;
+}
+/**
+ * 对象合并
+ * - 将两个对象递归合并为一个新对象，从右到左依次使用数值
+ * - 递归只适用于子对象属性
+ */
+export function objectAssign(obj, overrideObj) {
+    const result = {};
+    if (!isObject(obj) && !isObject(overrideObj)) {
+        return result;
+    }
+    if (!isObject(obj) || !isObject(overrideObj)) {
+        return obj ?? overrideObj ?? result;
+    }
+    return Object.entries({ ...obj, ...overrideObj }).reduce((prev, [key, value]) => {
+        return {
+            ...prev,
+            [key]: (() => {
+                if (isObject(obj[key])) {
+                    return objectAssign(obj[key], value);
+                }
+                return value;
+            })(),
+        };
+    }, result);
+}
+export function objectPick(obj, keys) {
+    const result = {};
+    if (!isObject(obj)) {
+        return result;
+    }
+    if (!isArray(keys)) {
+        return obj;
+    }
+    return keys.reduce((prev, curr) => {
+        if (curr in obj) {
+            prev[curr] = obj[curr];
+        }
+        return prev;
+    }, result);
+}
+function enumType(enumeration) {
+    if (!isObject(enumeration)) {
+        throw Error(`function enumKeys expected parameter is a enum, but got ${typeof enumeration}`);
+    }
+    if (!objectKeys(enumeration).length) {
+        throw Error("Enum requires at least one member");
+    }
+    return enumeration;
+}
+/**
+ * 获取枚举所有属性的键
+ *
+ * @param enumeration 枚举
+ */
+export function enumKeys(enumeration) {
+    const e = enumType(enumeration);
+    const keys = objectKeys(e);
+    const values = objectValues(e);
+    const isTwoWayEnum = keys.every((k) => values.some((v) => `${v}` === k));
+    if (isTwoWayEnum) {
+        return keys.splice(keys.length / 2, keys.length / 2);
+    }
+    return keys;
+}
+/**
+ * 获取枚举所有属性的值
+ *
+ * @param enumeration 枚举
+ */
+export function enumValues(enumeration) {
+    const e = enumType(enumeration);
+    const keys = objectKeys(e);
+    const values = objectValues(e);
+    const isTwoWayEnum = keys.every((k) => values.some((v) => `${v}` === k));
+    if (isTwoWayEnum) {
+        return values.splice(keys.length / 2, keys.length / 2);
+    }
+    return values;
+}
+/**
+ * 返回枚举的属性的键/值数组
+ *
+ * @param enumeration 枚举
+ */
+export function enumEntries(enumeration) {
+    const e = enumType(enumeration);
+    const keys = objectKeys(e);
+    const values = objectValues(e);
+    const entries = objectEntries(e);
+    const isTwoWayEnum = keys.every((k) => values.some((v) => `${v}` === k));
+    if (isTwoWayEnum) {
+        return entries.splice(keys.length / 2, keys.length / 2);
+    }
+    return entries;
+}

package/dist/utils/string.js

@@ -0,0 +1,70 @@
+import { isString } from "./typeof";
+/**
+ * 转义特殊字符
+ *
+ * @link https://github.com/sindresorhus/escape-string-regexp
+ * @param value 字符串
+ */
+export function escapeStringRegexp(value) {
+    return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+/**
+ * 首字母大小写
+ */
+export function stringInitialCase(value, type) {
+    if (!isString(value) || value.length === 0) {
+        return value;
+    }
+    const m1 = /\S+/g;
+    const m2 = /[^a-zA-Z\u00C0-\u017F]/;
+    return value.replace(m1, (word) => {
+        // 单词含非字母字符（如.,'-等）→ 原样保留
+        if (m2.test(word)) {
+            return word;
+        }
+        // 纯字母且全大写 → 保留
+        if (word === word.toLocaleUpperCase()) {
+            return word;
+        }
+        // 纯字母且非全大写 → 首字母小写，其余保留
+        if (type === "lower" && word[0]) {
+            return word[0].toLocaleLowerCase() + word.slice(1);
+        }
+        // 纯字母且非全大写 → 首字母大写写，其余保留
+        if (type === "upper" && word[0]) {
+            return word[0].toLocaleUpperCase() + word.slice(1);
+        }
+        return word;
+    });
+}
+export function stringToJson(data, safeValue) {
+    if (isString(data) && data) {
+        try {
+            const value = JSON.parse(data);
+            return value;
+        }
+        catch (error) {
+            return safeValue;
+        }
+    }
+    else {
+        return safeValue;
+    }
+}
+export function stringToValues(data, valueType = "number") {
+    if (isString(data) && data) {
+        try {
+            const values = data.split(",");
+            if (valueType === "number") {
+                return values.map((d) => Number(d));
+            }
+            return values;
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    else {
+        return [];
+    }
+}

package/dist/utils/to.js

@@ -0,0 +1,16 @@
+/**
+ * @param promise
+ * @param errorExt - 可以传递给err对象的其他信息
+ */
+export function to(promise, errorExt) {
+    return promise
+        .then((data) => [null, data])
+        .catch((err) => {
+        if (errorExt) {
+            const parsedError = { ...err, ...errorExt };
+            return [parsedError, undefined];
+        }
+        const defaultError = err ? err : new Error("defaultError");
+        return [defaultError, undefined];
+    });
+}

package/dist/utils/tree/index.js

@@ -0,0 +1,6 @@
+export { treeFilter } from "./treeFilter";
+export { treeFind } from "./treeFind";
+export { treeForEach } from "./treeForEach";
+export { treeMap } from "./treeMap";
+export { rowsToTree } from "./rowsToTree";
+export { treeToRows } from "./treeToRows";

package/dist/utils/tree/rowsToTree.js

@@ -0,0 +1,35 @@
+import { isNull, isUndefined } from "../typeof";
+/**
+ * 行结构 转 树结构
+ */
+export function rowsToTree(rows, options) {
+    const { parentIdKey = "parentId", rowKey = "id", childrenKey = "children" } = options || {};
+    const result = [];
+    const map = new Map();
+    for (const row of rows) {
+        const id = row[rowKey];
+        if (!map.get(id)) {
+            map.set(id, row);
+        }
+    }
+    for (const row of rows) {
+        const parentId = row[parentIdKey];
+        const parent = map.get(parentId);
+        if (!parent || !parentId) {
+            result.push(row);
+            continue;
+        }
+        const siblings = parent[childrenKey];
+        if (isNull(siblings) || isUndefined(siblings)) {
+            parent[childrenKey] = [row];
+        }
+        else if (Array.isArray(siblings)) {
+            siblings.push(row);
+        }
+        else {
+            const message = `The key "${childrenKey.toString()}" in parent item is not an array.`;
+            throw new Error(message);
+        }
+    }
+    return result;
+}

package/dist/utils/tree/treeFilter.js

@@ -0,0 +1,92 @@
+import { arrayLast } from "../array";
+import { isArray } from "../typeof";
+import { getFinalChildrenKey } from "./types";
+// 前置遍历
+function preImpl(row, callback, options) {
+    const result = callback(row, options);
+    if (!result) {
+        return undefined;
+    }
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    let newChildren;
+    if (isArray(children)) {
+        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+        newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions)).filter((c) => !!c);
+    }
+    return { ...row, [finalChildrenKey]: newChildren };
+}
+// 子节点优先遍历
+function postImpl(row, callback, options) {
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    let newChildren;
+    if (isArray(children)) {
+        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+        newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions)).filter((c) => !!c);
+    }
+    const result = callback(row, options);
+    if (!result) {
+        return undefined;
+    }
+    return { ...row, [finalChildrenKey]: newChildren };
+}
+// 广度优先遍历
+function breadthImpl(row, callback, options) {
+    const queue = [{ queueRow: row, queueOptions: options }];
+    const resultCache = new WeakMap();
+    const newNodeCache = new WeakMap();
+    const childrenKeyCache = new WeakMap();
+    let result;
+    const runQueue = () => {
+        if (queue.length === 0) {
+            return result;
+        }
+        const { queueRow, queueOptions } = queue.shift();
+        const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+        const children = queueRow[finalChildrenKey];
+        if (isArray(children)) {
+            const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };
+            const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));
+            queue.push(...subQueueItems);
+        }
+        const parent = arrayLast(queueOptions.parents);
+        const isTopNode = queueOptions.depth === 0;
+        const parentResult = parent && resultCache.get(parent);
+        if (!isTopNode && !parentResult) {
+            return runQueue();
+        }
+        const callbackResult = callback(queueRow, queueOptions);
+        if (isTopNode && !callbackResult) {
+            return undefined;
+        }
+        const newNode = { ...queueRow, [finalChildrenKey]: undefined };
+        if (isTopNode) {
+            result = newNode;
+        }
+        resultCache.set(queueRow, callbackResult);
+        newNodeCache.set(queueRow, newNode);
+        childrenKeyCache.set(queueRow, finalChildrenKey);
+        if (callbackResult && parent) {
+            const parentNewNode = newNodeCache.get(parent);
+            const parentChildrenKey = childrenKeyCache.get(parent);
+            if (parentNewNode && parentChildrenKey) {
+                if (!parentNewNode[parentChildrenKey]) {
+                    parentNewNode[parentChildrenKey] = [];
+                }
+                parentNewNode[parentChildrenKey].push(newNode);
+            }
+        }
+        return runQueue();
+    };
+    return runQueue();
+}
+const strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };
+export function treeFilter(tree, callback, options = {}) {
+    const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+    const traversalMethod = strategies[strategy];
+    const innerOptions = { childrenKey: childrenKey, depth: 0, parents: [], getChildrenKey };
+    return isArray(tree)
+        ? tree.map((row) => traversalMethod(row, callback, innerOptions)).filter((t) => !!t)
+        : traversalMethod(tree, callback, innerOptions) || [];
+}

package/dist/utils/tree/treeFind.js

@@ -0,0 +1,82 @@
+import { isArray } from "../typeof";
+import { getFinalChildrenKey } from "./types";
+const strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };
+// 前置深度优先遍历
+function preImpl(row, callback, options) {
+    const callbackResult = callback(row, options);
+    if (callbackResult) {
+        return row;
+    }
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    if (isArray(children)) {
+        for (const child of children) {
+            const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+            const result = preImpl(child, callback, nextLevelOptions);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return undefined;
+}
+// 后置深度优先遍历
+function postImpl(row, callback, options) {
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    if (isArray(children)) {
+        for (const child of children) {
+            const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+            const result = postImpl(child, callback, nextLevelOptions);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    const callbackResult = callback(row, options);
+    if (callbackResult) {
+        return row;
+    }
+    return undefined;
+}
+// 广度优先遍历
+function breadthImpl(row, callback, options) {
+    const queue = [{ queueRow: row, queueOptions: options }];
+    const runQueue = () => {
+        if (queue.length === 0) {
+            return undefined;
+        }
+        const { queueRow, queueOptions } = queue.shift();
+        const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+        const children = queueRow[finalChildrenKey];
+        if (isArray(children)) {
+            const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };
+            const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));
+            queue.push(...subQueueItems);
+        }
+        const callbackResult = callback(queueRow, queueOptions);
+        if (callbackResult) {
+            return queueRow;
+        }
+        return runQueue();
+    };
+    return runQueue();
+}
+/**
+ * 查找树节点，找到第一个返回非空值的节点
+ */
+export function treeFind(tree, callback, options = {}) {
+    const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+    const traversalMethod = strategies[strategy];
+    const innerOptions = { childrenKey: childrenKey, depth: 0, parents: [], getChildrenKey };
+    if (isArray(tree)) {
+        for (const row of tree) {
+            const result = traversalMethod(row, callback, innerOptions);
+            if (result) {
+                return result;
+            }
+        }
+        return undefined;
+    }
+    return traversalMethod(tree, callback, innerOptions);
+}