vome-core 0.1.14 → 0.1.16

package/src/shared/locale-json.ts

@@ -1,79 +0,0 @@
-import { createHash } from 'node:crypto'
-
-/** 嵌套对象 → 点分扁平 key */
-export function flattenLocale(
-  input: Record<string, unknown>,
-  prefix = '',
-): Record<string, string> {
-  const out: Record<string, string> = {}
-  for (const [k, v] of Object.entries(input)) {
-    const key = prefix ? `${prefix}.${k}` : k
-    if (v != null && typeof v === 'object' && !Array.isArray(v)) {
-      Object.assign(out, flattenLocale(v as Record<string, unknown>, key))
-    } else if (typeof v === 'string') {
-      out[key] = v
-    } else if (v != null) {
-      out[key] = String(v)
-    }
-  }
-  return out
-}
-
-/** 点分扁平 → 嵌套对象 */
-export function unflattenLocale(
-  flat: Record<string, string>,
-): Record<string, unknown> {
-  const root: Record<string, unknown> = {}
-  for (const [path, value] of Object.entries(flat)) {
-    const parts = path.split('.').filter(Boolean)
-    if (!parts.length) continue
-    let cur: Record<string, unknown> = root
-    for (let i = 0; i < parts.length - 1; i++) {
-      const p = parts[i]!
-      const next = cur[p]
-      if (!next || typeof next !== 'object' || Array.isArray(next)) {
-        cur[p] = {}
-      }
-      cur = cur[p] as Record<string, unknown>
-    }
-    cur[parts[parts.length - 1]!] = value
-  }
-  return root
-}
-
-export function hashLocaleJson(obj: Record<string, unknown>): string {
-  const flat = flattenLocale(obj)
-  const keys = Object.keys(flat).sort()
-  const payload = keys.map((k) => `${k}=${flat[k]}`).join('\n')
-  return createHash('sha256').update(payload).digest('hex').slice(0, 32)
-}
-
-/** 从模型回复中尽量抠出 JSON 对象 */
-export function extractJsonObject(text: string): Record<string, unknown> {
-  const raw = String(text || '').trim()
-  if (!raw) throw new Error('AI 返回空内容')
-  try {
-    const parsed = JSON.parse(raw) as unknown
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      return parsed as Record<string, unknown>
-    }
-  } catch {
-    /* try fence / substring */
-  }
-  const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/i)
-  if (fence?.[1]) {
-    const parsed = JSON.parse(fence[1].trim()) as unknown
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      return parsed as Record<string, unknown>
-    }
-  }
-  const start = raw.indexOf('{')
-  const end = raw.lastIndexOf('}')
-  if (start >= 0 && end > start) {
-    const parsed = JSON.parse(raw.slice(start, end + 1)) as unknown
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      return parsed as Record<string, unknown>
-    }
-  }
-  throw new Error('AI 返回无法解析为 JSON 对象')
-}

package/src/shared/tree.d.ts

@@ -1,18 +0,0 @@
-/** 扁平列表 → 树（parentId） */
-export declare function deepTree<T extends {
-    id?: number | string;
-    parentId?: number | string | null;
-    children?: T[];
-    orderNum?: number;
-}>(list: T[], sort?: 'asc' | 'desc'): T[];
-/** 树 → 扁平（带 depth / hasChildren），按 expanded 展开 */
-export declare function flattenTree<T extends {
-    id: number | string;
-    children?: T[];
-}>(nodes: T[], expanded: Set<string | number>, depth?: number, out?: Array<T & {
-    depth: number;
-    hasChildren: boolean;
-}>): Array<T & {
-    depth: number;
-    hasChildren: boolean;
-}>;

package/src/shared/tree.ts

@@ -1,50 +0,0 @@
-/** 扁平列表 → 树（parentId） */
-export function deepTree<
-  T extends {
-    id?: number | string
-    parentId?: number | string | null
-    children?: T[]
-    orderNum?: number
-  },
->(list: T[], sort: 'asc' | 'desc' = 'asc'): T[] {
-  const map = new Map<string | number, T>()
-  for (const row of list) {
-    if (row.id == null) continue
-    map.set(row.id, { ...row, children: [] })
-  }
-  const roots: T[] = []
-  for (const node of map.values()) {
-    const pid = node.parentId
-    if (pid != null && pid !== '' && map.has(pid as string | number)) {
-      map.get(pid as string | number)!.children!.push(node)
-    } else {
-      roots.push(node)
-    }
-  }
-  const sortRec = (arr: T[]) => {
-    arr.sort((a, b) => {
-      const ao = a.orderNum ?? 0
-      const bo = b.orderNum ?? 0
-      const d = sort === 'desc' ? bo - ao : ao - bo
-      return d || Number(a.id) - Number(b.id)
-    })
-    for (const n of arr) if (n.children?.length) sortRec(n.children)
-  }
-  sortRec(roots)
-  return roots
-}
-
-/** 树 → 扁平（带 depth / hasChildren），按 expanded 展开 */
-export function flattenTree<T extends { id: number | string; children?: T[] }>(
-  nodes: T[],
-  expanded: Set<string | number>,
-  depth = 0,
-  out: Array<T & { depth: number; hasChildren: boolean }> = [],
-): Array<T & { depth: number; hasChildren: boolean }> {
-  for (const n of nodes) {
-    const kids = n.children || []
-    out.push({ ...n, depth, hasChildren: kids.length > 0 })
-    if (kids.length && expanded.has(n.id)) flattenTree(kids, expanded, depth + 1, out)
-  }
-  return out
-}