@pawover/kit 0.0.0-alpha.9 → 0.0.0-beta.2

package/dist/utils/clone.js

@@ -1,75 +0,0 @@
-import { isArray, isMap, isObject, isSet } from "./typeof";
-export const DefaultCloningStrategy = {
-    cloneMap(input, track, clone) {
-        const output = track(new Map());
-        for (const [key, value] of input) {
-            output.set(key, clone(value));
-        }
-        return output;
-    },
-    cloneSet(input, track, clone) {
-        const output = track(new Set());
-        for (const value of input) {
-            output.add(clone(value));
-        }
-        return output;
-    },
-    cloneArray(input, track, clone) {
-        // Use .forEach for correct handling of sparse arrays
-        const output = track(new Array(input.length));
-        input.forEach((value, index) => {
-            output[index] = clone(value);
-        });
-        return output;
-    },
-    cloneObject(input, track, clone) {
-        const output = track(Object.create(Object.getPrototypeOf(input)));
-        for (const key of Reflect.ownKeys(input)) {
-            // By copying the property descriptors, we preserve computed
-            // properties and non-enumerable properties.
-            const descriptor = Object.getOwnPropertyDescriptor(input, key);
-            if ("value" in descriptor) {
-                descriptor.value = clone(descriptor.value);
-            }
-            Object.defineProperty(output, key, descriptor);
-        }
-        return output;
-    },
-    cloneOther(input, track) {
-        return track(input);
-    },
-};
-/**
- * cloneDeep
- * @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
- */
-export function cloneDeep(root, customStrategy) {
-    const strategy = { ...DefaultCloningStrategy, ...customStrategy };
-    const tracked = new Map();
-    const track = (parent, newParent) => {
-        tracked.set(parent, newParent);
-        return newParent;
-    };
-    const clone = (value) => {
-        return value && typeof value === "object" ? (tracked.get(value) ?? cloneDeep(value, strategy)) : value;
-    };
-    const cloneDeep = (parent, strategy) => {
-        const cloneParent = (isObject(parent)
-            ? strategy.cloneObject
-            : isArray(parent)
-                ? strategy.cloneArray
-                : isMap(parent)
-                    ? strategy.cloneMap
-                    : isSet(parent)
-                        ? strategy.cloneSet
-                        : strategy.cloneOther);
-        const newParent = cloneParent(parent, track.bind(null, parent), clone);
-        if (!newParent) {
-            // Use the default strategy if null is returned.
-            return cloneDeep(parent, DefaultCloningStrategy);
-        }
-        tracked.set(parent, newParent);
-        return newParent;
-    };
-    return cloneDeep(root, strategy);
-}

package/dist/utils/index.js

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

package/dist/utils/object.js

@@ -1,149 +0,0 @@
-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 objectEntries({ ...obj, ...overrideObj }).reduce((acc, [key, value]) => {
-        return {
-            ...acc,
-            [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((acc, curr) => {
-        if (curr in obj) {
-            acc[curr] = obj[curr];
-        }
-        return acc;
-    }, 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;
-}
-export function mapEntries(obj, toEntry) {
-    const defaultResult = {};
-    if (!obj) {
-        return defaultResult;
-    }
-    return objectEntries(obj).reduce((acc, [key, value]) => {
-        const [newKey, newValue] = toEntry(key, value);
-        acc[newKey] = newValue;
-        return acc;
-    }, defaultResult);
-}

package/dist/utils/string.js

@@ -1,73 +0,0 @@
-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 [];
-    }
-}
-export function stringReplace(input, search, replacement) {
-    return input.replace(search, replacement);
-}

package/dist/utils/to.js

@@ -1,16 +0,0 @@
-/**
- * @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

@@ -1,6 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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);
-}

package/dist/utils/tree/treeForEach.js

@@ -1,60 +0,0 @@
-import { isArray } from "../typeof";
-import { getFinalChildrenKey } from "./types";
-const strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };
-// 前置遍历
-function preImpl(row, callback, options) {
-    callback(row, options);
-    const finalChildrenKey = getFinalChildrenKey(row, options, options);
-    const children = row[finalChildrenKey];
-    if (isArray(children)) {
-        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
-        for (const child of children) {
-            preImpl(child, callback, nextLevelOptions);
-        }
-    }
-}
-// 后置遍历
-function postImpl(row, callback, options) {
-    const finalChildrenKey = getFinalChildrenKey(row, options, options);
-    const children = row[finalChildrenKey];
-    if (isArray(children)) {
-        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
-        for (const child of children) {
-            postImpl(child, callback, nextLevelOptions);
-        }
-    }
-    callback(row, options);
-}
-// 广度优先遍历
-function breadthImpl(row, callback, options) {
-    const queue = [{ queueRow: row, queueOptions: options }];
-    const runQueue = () => {
-        if (queue.length === 0) {
-            return;
-        }
-        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);
-        }
-        callback(queueRow, queueOptions);
-        runQueue();
-    };
-    runQueue();
-}
-export function treeForEach(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) {
-            traversalMethod(row, callback, innerOptions);
-        }
-    }
-    else {
-        traversalMethod(tree, callback, innerOptions);
-    }
-}

package/dist/utils/tree/treeMap.js

@@ -1,79 +0,0 @@
-import { arrayLast } from "../array";
-import { isArray } from "../typeof";
-import { getFinalChildrenKey } from "./types";
-const strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };
-// 前置遍历
-function preImpl(row, callback, options) {
-    const finalChildrenKey = getFinalChildrenKey(row, options, options);
-    const result = callback(row, 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));
-    }
-    return { ...result, [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) => postImpl(c, callback, nextLevelOptions));
-    }
-    const result = callback(row, options);
-    return { ...result, [finalChildrenKey]: newChildren };
-}
-// 广度优先遍历
-function breadthImpl(row, callback, options) {
-    const queue = [{ queueRow: row, queueOptions: options }];
-    const cache = 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 res = callback(queueRow, queueOptions);
-        cache.set(queueRow, res);
-        childrenKeyCache.set(queueRow, finalChildrenKey);
-        // breadth 模式的子节点一定晚于父节点执行，所以可以在cache中找到父节点的生成物
-        const parent = arrayLast(queueOptions.parents);
-        if (parent) {
-            const newParent = cache.get(parent);
-            const parentChildrenKey = childrenKeyCache.get(parent);
-            if (newParent && parentChildrenKey) {
-                if (newParent[parentChildrenKey]) {
-                    newParent[parentChildrenKey].push(res);
-                }
-                else {
-                    newParent[parentChildrenKey] = [res];
-                }
-            }
-        }
-        // 这棵树的顶点
-        if (queueOptions.depth === 0) {
-            result = res;
-        }
-        return runQueue();
-    };
-    return runQueue();
-}
-export function treeMap(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))
-        : traversalMethod(tree, callback, innerOptions);
-}