c-admin-kit 1.0.0

package/src/utils/treeManager.ts

@@ -0,0 +1,218 @@
+/**
+ * 通用树结构处理工具
+ */
+
+/**
+ * 递归从树中查找目标节点
+ * @param tree 树数组
+ * @param predicate 匹配函数
+ * @param childrenKey 子节点字段名，默认 'children'
+ * @returns 找到的节点对象
+ */
+export function findTreeNode<T extends Record<string, any>>(
+  tree: T[] = [],
+  predicate: (node: T) => boolean,
+  childrenKey: string = 'children'
+): T | null {
+  for (const node of tree) {
+    if (predicate(node)) return node
+    const children = node[childrenKey] as T[] | undefined
+    if (children && children.length > 0) {
+      const found = findTreeNode(children, predicate, childrenKey)
+      if (found) return found
+    }
+  }
+  return null
+}
+
+/**
+ * 获取从根节点到目标节点的完整祖先路径 (仅值列表，如 [1, 10, 102])
+ * @param tree 树结构
+ * @param targetValue 目标节点标识
+ * @param keyField 匹配键名，如 'id'
+ * @param childrenKey 子节点字段名
+ * @returns 包含从根到目标节点的所有路径标识
+ */
+export function findNodePath<T extends Record<string, any>>(
+  tree: T[] = [],
+  targetValue: any,
+  keyField: string = 'id',
+  childrenKey: string = 'children'
+): any[] {
+  const findPath = (nodes: T[], target: any, path: any[] = []): any[] => {
+    for (const node of nodes) {
+      const currentPath = [...path, node[keyField]]
+      if (node[keyField] === target) {
+        return currentPath
+      }
+      const children = node[childrenKey] as T[] | undefined
+      if (children && children.length > 0) {
+        const found = findPath(children, target, currentPath)
+        if (found.length > 0) return found
+      }
+    }
+    return []
+  }
+  return findPath(tree, targetValue)
+}
+
+/**
+ * 获取从根节点到目标节点的完整祖先节点对象列表 (包含目标节点自身)
+ * @param tree 树结构
+ * @param predicate 匹配条件或目标节点键值
+ * @param childrenKey 子节点字段名
+ * @returns 祖先节点对象数组，根节点在前
+ */
+export function findParentNodes<T extends Record<string, any>>(
+  tree: T[] = [],
+  predicate: ((node: T) => boolean) | any,
+  childrenKey: string = 'children',
+  keyField: string = 'id'
+): T[] {
+  const matchFn = typeof predicate === 'function' ? predicate : (node: T) => node[keyField] === predicate
+
+  const find = (nodes: T[], path: T[] = []): T[] => {
+    for (const node of nodes) {
+      const currentPath = [...path, node]
+      if (matchFn(node)) {
+        return currentPath
+      }
+      const children = node[childrenKey] as T[] | undefined
+      if (children && children.length > 0) {
+        const res = find(children, currentPath)
+        if (res.length > 0) return res
+      }
+    }
+    return []
+  }
+
+  return find(tree)
+}
+
+/**
+ * 树结构扁平化
+ * @param tree 树数组
+ * @param childrenKey 子节点字段名
+ * @returns 扁平化后的数组
+ */
+export function flattenTree<T extends Record<string, any>>(
+  tree: T[] = [],
+  childrenKey: string = 'children'
+): T[] {
+  const result: T[] = []
+  const traverse = (nodes: T[]) => {
+    nodes.forEach(node => {
+      result.push(node)
+      const children = node[childrenKey] as T[] | undefined
+      if (children && children.length > 0) {
+        traverse(children)
+      }
+    })
+  }
+  traverse(tree)
+  return result
+}
+
+/** 树转列表别名 */
+export const treeToList = flattenTree
+
+/**
+ * 扁平列表转树结构 (时间复杂度 O(n) 的高效 Map 算法)
+ * @param list 扁平列表
+ * @param options 配置项 { id: 'id', pid: 'parentId', children: 'children', rootPid: [0, null, undefined, ''] }
+ * @returns 构造完成的树数组
+ */
+export function listToTree<T extends Record<string, any>>(
+  list: T[] = [],
+  options: {
+    id?: string
+    pid?: string
+    children?: string
+    rootPid?: any[]
+  } = {}
+): T[] {
+  const {
+    id = 'id',
+    pid = 'parentId',
+    children = 'children',
+    rootPid = [0, '0', null, undefined, ''],
+  } = options
+
+  const nodeMap = new Map<any, T>()
+  const tree: T[] = []
+
+  // 深拷贝并建立 Map 映射
+  list.forEach((item) => {
+    nodeMap.set(item[id], { ...item, [children]: [] })
+  })
+
+  // 组织父子关系
+  list.forEach((item) => {
+    const node = nodeMap.get(item[id])!
+    const parentId = item[pid]
+
+    if (rootPid.includes(parentId) || !nodeMap.has(parentId)) {
+      tree.push(node)
+    } else {
+      const parent = nodeMap.get(parentId)
+      if (parent) {
+        ;(parent as any)[children].push(node)
+      }
+    }
+  })
+
+  return tree
+}
+
+/**
+ * 过滤树结构，保留满足条件的节点及其父链路
+ * @param tree 树数组
+ * @param predicate 过滤条件
+ * @param childrenKey 子节点字段名
+ * @returns 过滤后的新树结构
+ */
+export function filterTree<T extends Record<string, any>>(
+  tree: T[] = [],
+  predicate: (node: T) => boolean,
+  childrenKey: string = 'children'
+): T[] {
+  const filterNodes = (nodes: T[]): T[] => {
+    return nodes
+      .map(node => {
+        const clone = { ...node }
+        const children = clone[childrenKey] as T[] | undefined
+        if (children && children.length > 0) {
+          const filtered = filterNodes(children)
+          ;(clone as any)[childrenKey] = filtered.length > 0 ? filtered : undefined
+        }
+        const filteredChildren = (clone as any)[childrenKey] as T[] | undefined
+        if (predicate(clone) || (filteredChildren && filteredChildren.length > 0)) {
+          return clone
+        }
+        return null
+      })
+      .filter(Boolean) as T[]
+  }
+  return filterNodes(tree)
+}
+
+/**
+ * 树结构映射/转换 (类似于数组的 map)
+ * @param tree 树数组
+ * @param mapper 节点转换器
+ * @param childrenKey 子节点字段名
+ */
+export function mapTree<T extends Record<string, any>, R extends Record<string, any>>(
+  tree: T[] = [],
+  mapper: (node: T) => R,
+  childrenKey: string = 'children'
+): R[] {
+  return tree.map((node) => {
+    const mapped = mapper(node)
+    const children = node[childrenKey] as T[] | undefined
+    if (children && children.length > 0) {
+      ;(mapped as any)[childrenKey] = mapTree(children, mapper, childrenKey)
+    }
+    return mapped
+  })
+}

package/src/utils/validate.ts

@@ -0,0 +1,64 @@
+/**
+ * 路径匹配器
+ */
+export function isPathMatch(pattern: string, path: string): boolean {
+  const regexPattern = pattern.replace(/\//g, '\\/').replace(/\*\*/g, '.*').replace(/\*/g, '[^\\/]*')
+  const regex = new RegExp(`^${regexPattern}$`)
+  return regex.test(path)
+}
+
+/**
+ * 判断value字符串是否为空 
+ */
+export function isEmpty(value: unknown): boolean {
+  if (value == null || value === "" || value === undefined || value === "undefined") {
+    return true
+  }
+  return false
+}
+
+/**
+ * 判断url是否是http或https 
+ */
+export function isHttp(url: string): boolean {
+  if (!url || typeof url !== 'string') return false
+  return url.indexOf('http://') !== -1 || url.indexOf('https://') !== -1
+}
+
+/**
+ * 判断path是否为外链
+ */
+export function isExternal(path: string): boolean {
+  return /^(https?:|mailto:|tel:)/.test(path)
+}
+
+/**
+ * 验证合法 URL
+ */
+export function validURL(url: string): boolean {
+  const reg = /^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/
+  return reg.test(url)
+}
+
+/**
+ * 验证邮箱
+ */
+export function validEmail(email: string): boolean {
+  const reg = /^(([^<>()[\]\\.,;:\s@"]+(\.[[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
+  return reg.test(email)
+}
+
+/**
+ * 验证手机号
+ */
+export function validPhone(phone: string): boolean {
+  return /^1[3-9]\d{9}$/.test(phone)
+}
+
+export function isString(str: unknown): str is string {
+  return typeof str === 'string' || str instanceof String
+}
+
+export function isArray(arg: unknown): arg is any[] {
+  return Array.isArray(arg)
+}