zhiaiwan-utils 1.0.3

package/dist/esm/_internal/baseMerge.js

@@ -0,0 +1,132 @@
+import isPlainObject from './isPlainObject';
+function createMergeTarget(value) {
+    return Array.isArray(value) ? [] : {};
+}
+function setNestedValue(container, key, value) {
+    if (Array.isArray(container)) {
+        const index = Number(key);
+        container[index] = value;
+        if (index >= container.length) {
+            container.length = index + 1;
+        }
+        return;
+    }
+    container[String(key)] = value;
+}
+function applyCustomizer(target, key, objValue, srcValue, source, customizer, stack) {
+    if (!customizer) {
+        return false;
+    }
+    const customized = customizer(objValue, srcValue, key, target, source, stack);
+    if (customized === undefined) {
+        return false;
+    }
+    setNestedValue(target, key, customized);
+    return true;
+}
+function assignMergeValue(target, key, objValue, srcValue, source, customizer, stack) {
+    if (applyCustomizer(target, key, objValue, srcValue, source, customizer, stack)) {
+        return;
+    }
+    if (objValue === undefined) {
+        target[key] = srcValue;
+        return;
+    }
+    if (isPlainObject(objValue) && isPlainObject(srcValue)) {
+        baseMergeWith(objValue, srcValue, customizer, stack);
+        return;
+    }
+    if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+        baseMergeWith(objValue, srcValue, customizer, stack);
+        return;
+    }
+    target[key] = srcValue;
+}
+/**
+ * 内部辅助：深合并 source 到 object，行为对齐 Lodash merge / mergeWith。
+ *
+ * @internal
+ */
+export default function baseMergeWith(object, source, customizer, stack = new Map()) {
+    if (source == null) {
+        return;
+    }
+    if (Array.isArray(source)) {
+        if (!Array.isArray(object)) {
+            return;
+        }
+        const target = object;
+        const srcArray = source;
+        for (let index = 0; index < srcArray.length; index++) {
+            const srcValue = srcArray[index];
+            if (srcValue === undefined) {
+                continue;
+            }
+            const objValue = target[index];
+            if (applyCustomizer(target, index, objValue, srcValue, source, customizer, stack)) {
+                continue;
+            }
+            if (isPlainObject(srcValue)) {
+                const nextTarget = isPlainObject(objValue) ? objValue : createMergeTarget(srcValue);
+                if (nextTarget !== objValue) {
+                    target[index] = nextTarget;
+                }
+                baseMergeWith(nextTarget, srcValue, customizer, stack);
+                continue;
+            }
+            if (Array.isArray(srcValue)) {
+                const nextTarget = Array.isArray(objValue) ? objValue : createMergeTarget(srcValue);
+                if (nextTarget !== objValue) {
+                    target[index] = nextTarget;
+                }
+                baseMergeWith(nextTarget, srcValue, customizer, stack);
+                continue;
+            }
+            target[index] = srcValue;
+        }
+        return;
+    }
+    if (!isPlainObject(source)) {
+        return;
+    }
+    if (typeof object !== 'object' || object === null || Array.isArray(object)) {
+        return;
+    }
+    const target = object;
+    const srcObject = source;
+    for (const key of Object.keys(srcObject)) {
+        const srcValue = srcObject[key];
+        if (srcValue === undefined) {
+            continue;
+        }
+        const objValue = target[key];
+        if (applyCustomizer(target, key, objValue, srcValue, source, customizer, stack)) {
+            continue;
+        }
+        if (isPlainObject(srcValue)) {
+            const nextTarget = isPlainObject(objValue) ? objValue : createMergeTarget(srcValue);
+            if (nextTarget !== objValue) {
+                target[key] = nextTarget;
+            }
+            baseMergeWith(nextTarget, srcValue, customizer, stack);
+            continue;
+        }
+        if (Array.isArray(srcValue)) {
+            const nextTarget = Array.isArray(objValue) ? objValue : createMergeTarget(srcValue);
+            if (nextTarget !== objValue) {
+                target[key] = nextTarget;
+            }
+            baseMergeWith(nextTarget, srcValue, customizer, stack);
+            continue;
+        }
+        assignMergeValue(target, key, objValue, srcValue, source, customizer, stack);
+    }
+}
+/**
+ * 内部辅助：无自定义合并器的深合并。
+ *
+ * @internal
+ */
+export function baseMerge(object, source) {
+    baseMergeWith(object, source);
+}

package/dist/esm/_internal/basePad.js

@@ -0,0 +1,34 @@
+import repeatString from './repeatString';
+import toLength from './toLength';
+function normalizeChars(chars) {
+    if (chars === undefined) {
+        return ' ';
+    }
+    return chars.length === 0 ? ' ' : String(chars);
+}
+function createPadding(string, length, chars, side) {
+    const padLength = length - string.length;
+    if (padLength <= 0) {
+        return string;
+    }
+    const padding = repeatString(chars, Math.ceil(padLength / chars.length)).slice(0, padLength);
+    if (side === 'start') {
+        return padding + string;
+    }
+    if (side === 'end') {
+        return string + padding;
+    }
+    const leftLength = Math.floor(padLength / 2);
+    const rightLength = padLength - leftLength;
+    const left = padding.slice(0, leftLength);
+    const right = repeatString(chars, Math.ceil(rightLength / chars.length)).slice(0, rightLength);
+    return left + string + right;
+}
+/**
+ * 内部辅助：按指定方向填充字符串到目标长度。
+ *
+ * @internal
+ */
+export function padString(value, length, chars, side) {
+    return createPadding(value, toLength(length), normalizeChars(chars), side);
+}

package/dist/esm/_internal/basePath.js

@@ -0,0 +1,77 @@
+import isIndex from './isIndex';
+import toPath from './toPath';
+function createNestedValue(nextKey) {
+    return isIndex(nextKey) ? [] : {};
+}
+function assignValue(container, key, value) {
+    if (Array.isArray(container) && isIndex(key)) {
+        const index = Number(key);
+        container[index] = value;
+        if (index >= container.length) {
+            container.length = index + 1;
+        }
+        return;
+    }
+    container[key] = value;
+}
+function getNestedValue(container, key) {
+    return container[key];
+}
+/**
+ * 内部辅助：按路径读取值。
+ *
+ * @internal
+ */
+export function getPathValue(object, path) {
+    const keys = toPath(path);
+    let current = object;
+    for (const key of keys) {
+        if (current == null) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * 内部辅助：判断路径是否为自有属性链。
+ *
+ * @internal
+ */
+export function hasPath(object, path) {
+    const keys = toPath(path);
+    if (keys.length === 0) {
+        return false;
+    }
+    let current = object;
+    for (const key of keys) {
+        if (current == null || !Object.prototype.hasOwnProperty.call(Object(current), key)) {
+            return false;
+        }
+        current = current[key];
+    }
+    return true;
+}
+/**
+ * 内部辅助：按路径写入值，必要时创建中间节点。
+ *
+ * @internal
+ */
+export function setPathValue(object, path, value) {
+    const keys = toPath(path);
+    if (keys.length === 0) {
+        return;
+    }
+    let current = object;
+    for (let index = 0; index < keys.length - 1; index++) {
+        const key = keys[index];
+        const nextKey = keys[index + 1];
+        let next = getNestedValue(current, key);
+        if (next == null || typeof next !== 'object') {
+            next = createNestedValue(nextKey);
+            assignValue(current, key, next);
+        }
+        current = next;
+    }
+    assignValue(current, keys[keys.length - 1], value);
+}

package/dist/esm/_internal/baseRange.js

@@ -0,0 +1,15 @@
+/**
+ * 生成数字范围，对齐 Lodash baseRange。
+ *
+ * @internal
+ */
+export default function baseRange(start, end, step, fromRight = false) {
+    const length = Math.max(Math.ceil((end - start) / (step || 1)), 0);
+    const result = new Array(length);
+    for (let index = 0; index < length; index++) {
+        const position = fromRight ? length - 1 - index : index;
+        result[position] = start;
+        start += step;
+    }
+    return result;
+}

package/dist/esm/_internal/baseReduce.js

@@ -0,0 +1,71 @@
+import isArrayLike from './isArrayLike';
+function reduceArray(array, iteratee, accumulator, initAccum, fromRight) {
+    const length = array.length;
+    if (!length) {
+        return accumulator;
+    }
+    let index = fromRight ? length - 1 : 0;
+    let init = initAccum;
+    if (init) {
+        accumulator = array[index];
+        index += fromRight ? -1 : 1;
+        init = false;
+    }
+    if (fromRight) {
+        while (index >= 0) {
+            accumulator = iteratee(accumulator, array[index], index, array);
+            index -= 1;
+        }
+    }
+    else {
+        while (index < length) {
+            accumulator = iteratee(accumulator, array[index], index, array);
+            index += 1;
+        }
+    }
+    return accumulator;
+}
+function reduceCollection(collection, iteratee, accumulator, initAccum, fromRight) {
+    var _a;
+    if (collection == null) {
+        return accumulator;
+    }
+    if (typeof collection === 'string') {
+        return reduceArray([...collection], iteratee, accumulator, initAccum, fromRight);
+    }
+    if (Array.isArray(collection)) {
+        return reduceArray(collection, iteratee, accumulator, initAccum, fromRight);
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        const array = Array.from({ length }, (_, index) => arrayLike[index]);
+        return reduceArray(array, iteratee, accumulator, initAccum, fromRight);
+    }
+    if (typeof collection === 'object') {
+        const keys = Object.keys(collection);
+        const orderedKeys = fromRight ? [...keys].reverse() : keys;
+        let init = initAccum;
+        for (const key of orderedKeys) {
+            const value = collection[key];
+            if (init) {
+                accumulator = value;
+                init = false;
+                continue;
+            }
+            accumulator = iteratee(accumulator, value, key, collection);
+        }
+    }
+    return accumulator;
+}
+/**
+ * reduce / reduceRight 共享内核，语义对齐 Lodash baseReduce。
+ *
+ * @internal
+ */
+export default function baseReduce(collection, iteratee, accumulator, initAccum, fromRight = false) {
+    if (Array.isArray(collection)) {
+        return reduceArray(collection, iteratee, accumulator, initAccum, fromRight);
+    }
+    return reduceCollection(collection, iteratee, accumulator, initAccum, fromRight);
+}

package/dist/esm/_internal/baseSum.js

@@ -0,0 +1,21 @@
+import identity from './identity';
+/**
+ * 按 iteratee 返回值累加，跳过 `undefined`；使用 `+` 做 Lodash 式 coercion。
+ *
+ * @internal
+ */
+export default function baseSum(array, iteratee = identity) {
+    if (array == null || array.length === 0) {
+        return 0;
+    }
+    let result;
+    for (let index = 0; index < array.length; index++) {
+        const current = iteratee(array[index], index, array);
+        if (current === undefined) {
+            continue;
+        }
+        const numeric = current;
+        result = result === undefined ? numeric : result + numeric;
+    }
+    return result !== null && result !== void 0 ? result : 0;
+}

package/dist/esm/_internal/baseTreeTraverse.js

@@ -0,0 +1,219 @@
+/** 非正整数 maxDepth 统一视为 0（不限制深度） */
+export function normalizeTreeMaxDepth(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        return 0;
+    }
+    return value;
+}
+/** maxDepth 为 0 时不限制；否则仅在该 depth 上匹配 */
+export function shouldMatchTreeDepth(depth, maxDepth) {
+    return maxDepth === 0 || depth === maxDepth;
+}
+/** 树遍历默认字段映射，与后台菜单等常见结构对齐 */
+export const DEFAULT_TREE_TRAVERSE_FIELDS = {
+    childrenKey: 'children',
+    keyField: 'id',
+    parentIdField: 'parentId',
+    labelField: 'title',
+};
+function shouldBreak(result) {
+    return result === false;
+}
+function readField(node, field) {
+    if (node != null && typeof node === 'object') {
+        return node[field];
+    }
+    return undefined;
+}
+function resolveTreeTraverseOptions(options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const childrenKey = (_a = options.childrenKey) !== null && _a !== void 0 ? _a : DEFAULT_TREE_TRAVERSE_FIELDS.childrenKey;
+    const keyField = (_b = options.keyField) !== null && _b !== void 0 ? _b : DEFAULT_TREE_TRAVERSE_FIELDS.keyField;
+    const labelField = (_c = options.labelField) !== null && _c !== void 0 ? _c : DEFAULT_TREE_TRAVERSE_FIELDS.labelField;
+    const parentIdField = (_d = options.parentIdField) !== null && _d !== void 0 ? _d : DEFAULT_TREE_TRAVERSE_FIELDS.parentIdField;
+    const getKey = (_e = options.getKey) !== null && _e !== void 0 ? _e : ((node) => readField(node, keyField));
+    const getLabel = (_f = options.getLabel) !== null && _f !== void 0 ? _f : ((node) => readField(node, labelField));
+    const getParentKey = (_g = options.getParentKey) !== null && _g !== void 0 ? _g : ((node, _parent, parentKey) => {
+        const fromNode = readField(node, parentIdField);
+        if (fromNode !== undefined) {
+            return fromNode;
+        }
+        return parentKey;
+    });
+    return {
+        childrenKey,
+        keyField,
+        parentIdField,
+        labelField,
+        getKey,
+        getParentKey,
+        getLabel,
+        maxDepth: normalizeTreeMaxDepth(options.maxDepth),
+    };
+}
+function getChildNodes(node, childrenKey) {
+    if (node == null || typeof node !== 'object') {
+        return [];
+    }
+    const children = node[childrenKey];
+    return Array.isArray(children) ? children : [];
+}
+function normalizeRoots(tree) {
+    if (tree == null) {
+        return [];
+    }
+    return Array.isArray(tree) ? tree : [tree];
+}
+function invokeIteratee(current, iteratee) {
+    return iteratee(current.node, current.parent, current.depth, current.index, {
+        parentNodes: current.parentNodes,
+    });
+}
+function isTreeCycle(node, nodeKey, pathKeys, pathObjects) {
+    if (pathKeys.has(nodeKey)) {
+        return true;
+    }
+    if (node != null && typeof node === 'object' && pathObjects.has(node)) {
+        return true;
+    }
+    return false;
+}
+function enterTreePath(node, nodeKey, pathKeys, pathObjects) {
+    pathKeys.add(nodeKey);
+    if (node != null && typeof node === 'object') {
+        pathObjects.add(node);
+    }
+}
+function exitTreePath(node, nodeKey, pathKeys, pathObjects) {
+    pathKeys.delete(nodeKey);
+    if (node != null && typeof node === 'object') {
+        pathObjects.delete(node);
+    }
+}
+function shouldDescendTree(resolved, depth) {
+    return resolved.maxDepth === 0 || depth < resolved.maxDepth;
+}
+function runIterateeAtDepth(ctx, iteratee, resolved, stopOnFalse, invokeAtAllDepths) {
+    if (!invokeAtAllDepths && !shouldMatchTreeDepth(ctx.depth, resolved.maxDepth)) {
+        return true;
+    }
+    const result = invokeIteratee(ctx, iteratee);
+    if (stopOnFalse && shouldBreak(result)) {
+        return false;
+    }
+    return true;
+}
+function walkDepthFirst(roots, iteratee, resolved, stopOnFalse, invokeAtAllDepths) {
+    const stack = [];
+    const pathKeys = new Set();
+    const pathObjects = new Set();
+    for (let index = roots.length - 1; index >= 0; index--) {
+        stack.push({
+            ctx: {
+                node: roots[index],
+                parent: null,
+                parentKey: undefined,
+                parentNodes: [],
+                depth: 0,
+                index,
+            },
+        });
+    }
+    while (stack.length > 0) {
+        const item = stack.pop();
+        const { ctx } = item;
+        if (item.exiting) {
+            exitTreePath(ctx.node, resolved.getKey(ctx.node), pathKeys, pathObjects);
+            continue;
+        }
+        const nodeKey = resolved.getKey(ctx.node);
+        if (isTreeCycle(ctx.node, nodeKey, pathKeys, pathObjects)) {
+            continue;
+        }
+        enterTreePath(ctx.node, nodeKey, pathKeys, pathObjects);
+        if (!runIterateeAtDepth(ctx, iteratee, resolved, stopOnFalse, invokeAtAllDepths)) {
+            return false;
+        }
+        stack.push({ ctx, exiting: true });
+        if (shouldDescendTree(resolved, ctx.depth)) {
+            const children = getChildNodes(ctx.node, resolved.childrenKey);
+            for (let index = children.length - 1; index >= 0; index--) {
+                stack.push({
+                    ctx: {
+                        node: children[index],
+                        parent: ctx.node,
+                        parentKey: nodeKey,
+                        parentNodes: ctx.parentNodes.concat(ctx.node),
+                        depth: ctx.depth + 1,
+                        index,
+                    },
+                });
+            }
+        }
+    }
+    return true;
+}
+function walkBreadthFirst(roots, iteratee, resolved, stopOnFalse, invokeAtAllDepths) {
+    const queue = roots.map((node, index) => ({
+        ctx: {
+            node: node,
+            parent: null,
+            parentKey: undefined,
+            parentNodes: [],
+            depth: 0,
+            index,
+        },
+        pathKeys: new Set(),
+        pathObjects: new Set(),
+    }));
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const { ctx, pathKeys, pathObjects } = current;
+        const nodeKey = resolved.getKey(ctx.node);
+        if (isTreeCycle(ctx.node, nodeKey, pathKeys, pathObjects)) {
+            continue;
+        }
+        const nextPathKeys = new Set(pathKeys);
+        const nextPathObjects = new Set(pathObjects);
+        enterTreePath(ctx.node, nodeKey, nextPathKeys, nextPathObjects);
+        if (!runIterateeAtDepth(ctx, iteratee, resolved, stopOnFalse, invokeAtAllDepths)) {
+            return false;
+        }
+        const shouldDescend = shouldDescendTree(resolved, ctx.depth);
+        if (shouldDescend) {
+            const children = getChildNodes(ctx.node, resolved.childrenKey);
+            for (let index = 0; index < children.length; index++) {
+                queue.push({
+                    ctx: {
+                        node: children[index],
+                        parent: ctx.node,
+                        parentKey: nodeKey,
+                        parentNodes: ctx.parentNodes.concat(ctx.node),
+                        depth: ctx.depth + 1,
+                        index,
+                    },
+                    pathKeys: nextPathKeys,
+                    pathObjects: nextPathObjects,
+                });
+            }
+        }
+    }
+    return true;
+}
+/**
+ * 树遍历内核；`order` 控制 DFS / BFS，`stopOnFalse` 对齐 forEach 中断语义。
+ *
+ * @internal
+ */
+export default function baseTreeTraverse(tree, iteratee, options = {}, order, stopOnFalse, invokeAtAllDepths = false) {
+    const resolved = resolveTreeTraverseOptions(options);
+    const roots = normalizeRoots(tree);
+    if (!roots.length) {
+        return true;
+    }
+    if (order === 'bfs') {
+        return walkBreadthFirst(roots, iteratee, resolved, stopOnFalse, invokeAtAllDepths);
+    }
+    return walkDepthFirst(roots, iteratee, resolved, stopOnFalse, invokeAtAllDepths);
+}
+export { resolveTreeTraverseOptions };

package/dist/esm/_internal/baseTrim.js

@@ -0,0 +1,29 @@
+/**
+ * 内部辅助：按指定字符集裁剪字符串两端。
+ *
+ * @internal
+ */
+export function trimByChars(string, chars, side) {
+    if (chars === undefined) {
+        if (side === 'start') {
+            return string.trimStart();
+        }
+        if (side === 'end') {
+            return string.trimEnd();
+        }
+        return string.trim();
+    }
+    let start = 0;
+    let end = string.length;
+    if (side === 'both' || side === 'start') {
+        while (start < end && chars.includes(string[start])) {
+            start++;
+        }
+    }
+    if (side === 'both' || side === 'end') {
+        while (end > start && chars.includes(string[end - 1])) {
+            end--;
+        }
+    }
+    return string.slice(start, end);
+}

package/dist/esm/_internal/baseUnset.js

@@ -0,0 +1,43 @@
+import isIndex from './isIndex';
+import toPath from './toPath';
+function getNestedValue(container, key) {
+    return container[key];
+}
+function deleteNestedValue(container, key) {
+    if (Array.isArray(container) && isIndex(key)) {
+        delete container[Number(key)];
+        return;
+    }
+    delete container[key];
+}
+/**
+ * 内部辅助：删除 object 上 path 对应属性，行为对齐 Lodash unset。
+ *
+ * @internal
+ */
+export default function baseUnset(object, path) {
+    const keys = toPath(path);
+    if (keys.length === 0 || object == null) {
+        return true;
+    }
+    let current = object;
+    for (let index = 0; index < keys.length; index++) {
+        const key = keys[index];
+        if (current == null) {
+            return false;
+        }
+        if (index === keys.length - 1) {
+            if (!Object.prototype.hasOwnProperty.call(Object(current), key)) {
+                return true;
+            }
+            deleteNestedValue(current, key);
+            return true;
+        }
+        const next = getNestedValue(current, key);
+        if (next == null || typeof next !== 'object') {
+            return false;
+        }
+        current = next;
+    }
+    return false;
+}