vome-core 0.0.9 → 0.0.12

package/src/admin/router/menu-routes.ts

@@ -1,126 +0,0 @@
-import type { Router, RouteRecordRaw } from 'vue-router'
-import { defineComponent, h } from 'vue'
-import { resolveView, viewPathToName } from '../lib/module'
-import MissingView from '#vome-host/pages/missing/index.vue'
-import MicroAppView from '#vome-host/pages/micro/index.vue'
-
-/** 已挂载的动态菜单路由名 menu-${id} */
-const addedNames = new Set<string>()
-
-function isMicroMenu(m: MenuTreeNode) {
-  return Boolean(m.appKey && m.router)
-}
-
-function walk(nodes: MenuTreeNode[], out: MenuTreeNode[]) {
-  for (const n of nodes) {
-    if (Number(n.type) === 1 && n.router) out.push(n)
-    if (n.children?.length) walk(n.children, out)
-  }
-}
-
-function missingView(viewPath: string) {
-  return defineComponent({
-    name: 'MissingViewPage',
-    setup() {
-      return () => h(MissingView, { path: viewPath })
-    },
-  })
-}
-
-function routeNameOf(id: number | string) {
-  return `menu-${id}`
-}
-
-function buildRoute(item: MenuTreeNode): RouteRecordRaw {
-  const full = item.router!
-  const childPath = full.replace(/^\//, '')
-  let component: RouteRecordRaw['component']
-  const componentName = viewPathToName(item.viewPath)
-  const meta: Record<string, unknown> = {
-    title: item.name,
-    keepAlive: item.keepAlive !== false,
-    viewPath: item.viewPath,
-    perms: item.perms,
-    componentName,
-  }
-
-  if (isMicroMenu(item)) {
-    component = MicroAppView
-    meta.appKey = item.appKey
-    meta.componentName = `micro-${item.appKey}`
-    meta.keepAlive = false
-  } else if (item.viewPath) {
-    const loader = resolveView(item.viewPath)
-    component = loader || missingView(item.viewPath)
-  } else {
-    component = missingView(full)
-  }
-
-  return {
-    path: childPath,
-    name: routeNameOf(item.id),
-    component,
-    meta,
-  }
-}
-
-/** 根据权限菜单动态挂载：viewPath 本地模块 / appKey 微应用（仅补新增） */
-export async function ensureMenuRoutes(router: Router, menus: MenuTreeNode[]) {
-  const items: MenuTreeNode[] = []
-  walk(menus, items)
-
-  for (const item of items) {
-    const name = routeNameOf(item.id)
-    if (addedNames.has(name)) continue
-    addedNames.add(name)
-    router.addRoute('layout', buildRoute(item))
-  }
-}
-
-/** 全量同步：删旧补新，菜单改名/改路由/显隐后侧栏与路由一致 */
-export async function syncMenuRoutes(router: Router, menus: MenuTreeNode[]) {
-  const items: MenuTreeNode[] = []
-  walk(menus, items)
-  const nextNames = new Set(items.map((i) => routeNameOf(i.id)))
-
-  for (const name of [...addedNames]) {
-    if (!nextNames.has(name)) {
-      if (router.hasRoute(name)) router.removeRoute(name)
-      addedNames.delete(name)
-    }
-  }
-
-  for (const item of items) {
-    const name = routeNameOf(item.id)
-    const childPath = item.router!.replace(/^\//, '')
-    if (addedNames.has(name) && router.hasRoute(name)) {
-      const existing = router.getRoutes().find((r) => r.name === name)
-      if (existing && existing.path.replace(/^\//, '') !== childPath) {
-        router.removeRoute(name)
-        addedNames.delete(name)
-      } else if (existing?.meta) {
-        existing.meta.title = item.name
-        existing.meta.keepAlive = item.keepAlive !== false
-        existing.meta.viewPath = item.viewPath
-        existing.meta.perms = item.perms
-        if (item.appKey) existing.meta.appKey = item.appKey
-        continue
-      }
-    }
-    if (!addedNames.has(name)) {
-      addedNames.add(name)
-      router.addRoute('layout', buildRoute(item))
-    }
-  }
-}
-
-export function clearMenuRoutesFlag() {
-  addedNames.clear()
-}
-
-export function removeAllMenuRoutes(router: Router) {
-  for (const name of [...addedNames]) {
-    if (router.hasRoute(name)) router.removeRoute(name)
-  }
-  addedNames.clear()
-}

package/src/admin/service/base.ts

@@ -1,96 +0,0 @@
-import { request } from '../api/client'
-/** 系统时间由后端维护；所有方法请求体都不传 */
-function stripTimeMeta(data: unknown): unknown {
-  if (Array.isArray(data)) return data.map((item) => stripTimeMeta(item))
-  if (data && typeof data === 'object') {
-    const out = { ...(data as Record<string, unknown>) }
-    delete out.createTime
-    delete out.updateTime
-    return out
-  }
-  return data
-}
-
-/** BaseService：namespace + request + 标准 CRUD */
-export class BaseService {
-  namespace?: string
-
-  constructor(namespace?: string) {
-    if (namespace) this.namespace = namespace.replace(/^\//, '')
-  }
-
-  async request(options: ServiceRequestOptions = {}) {
-    let url = options.url || ''
-
-    if (url && !/^https?:\/\//.test(url)) {
-      if (this.namespace) {
-        const ns = this.namespace.startsWith('/')
-          ? this.namespace
-          : `/${this.namespace}`
-        url = url.startsWith('/') ? `${ns}${url}` : `${ns}/${url}`
-      }
-      if (!url.startsWith('/')) url = `/${url}`
-    }
-
-    const method = (options.method || 'GET').toUpperCase()
-    if (method === 'GET') {
-      const params = options.params || {}
-      const q = new URLSearchParams()
-      for (const [k, v] of Object.entries(params)) {
-        if (v == null) continue
-        q.set(k, String(v))
-      }
-      const qs = q.toString()
-      return request(qs ? `${url}?${qs}` : url)
-    }
-
-    return request(url, {
-      method,
-      body: JSON.stringify(stripTimeMeta(options.data ?? {})),
-    })
-  }
-
-  page(data: Record<string, unknown> = {}) {
-    return this.request({ url: '/page', method: 'POST', data }) as Promise<{
-      list: Record<string, unknown>[]
-      pagination: { page: number; size: number; total: number }
-    }>
-  }
-
-  list(data: Record<string, unknown> = {}) {
-    return this.request({
-      url: '/list',
-      method: 'POST',
-      data,
-    }) as Promise<Record<string, unknown>[]>
-  }
-
-  info(params: { id: number | string }) {
-    return this.request({
-      url: '/info',
-      method: 'GET',
-      params: params as Record<string, unknown>,
-    }) as Promise<Record<string, unknown>>
-  }
-
-  add(data: Record<string, unknown> | Record<string, unknown>[]) {
-    return this.request({ url: '/add', method: 'POST', data })
-  }
-
-  update(data: Record<string, unknown> | Record<string, unknown>[]) {
-    return this.request({ url: '/update', method: 'POST', data })
-  }
-
-  delete(
-    data:
-      | { ids: Array<number | string>; force?: boolean }
-      | Array<number | string>
-      | Array<Record<string, unknown>>,
-  ) {
-    return this.request({ url: '/delete', method: 'POST', data })
-  }
-
-  restore(data: { ids: Array<number | string> }) {
-    return this.request({ url: '/restore', method: 'POST', data })
-  }
-}

package/src/admin/service/index.ts

@@ -1,413 +0,0 @@
-import { loadEps } from '../lib/eps'
-import { BaseService } from './base'
-
-const SIDE_ID = 'admin'
-
-/**
- * 每次发版递增。globalThis 单例若跨 HMR/旧包残留，靠此戳强制换新根对象并重建。
- * 根因：旧 singleton 只有 CRUD、无 tree/roleMap，且 plugin-info 错名导致 base.plugin 缺失。
- */
-const SERVICE_BUILD = 9
-
-/** 标准 CRUD 之外的常用接口（不依赖 EPS 是否已返回） */
-const FALLBACK_EXTRA_APIS: Record<
-  string,
-  Array<{ method: string; path: string; perms?: string[] }>
-> = {
-  '/admin/base/department': [{ method: 'get', path: '/tree' }],
-  '/admin/base/menu': [{ method: 'get', path: '/tree' }],
-  '/admin/base/role': [
-    { method: 'get', path: '/menus' },
-    { method: 'post', path: '/setMenus' },
-    { method: 'get', path: '/departments' },
-    { method: 'post', path: '/setDepartments' },
-  ],
-  '/admin/base/user': [
-    { method: 'get', path: '/roles' },
-    { method: 'get', path: '/roleMap' },
-    { method: 'post', path: '/setRoles' },
-    { method: 'post', path: '/transferSuper' },
-    { method: 'post', path: '/moveDepartment' },
-  ],
-  '/admin/base/task': [
-    { method: 'post', path: '/start' },
-    { method: 'post', path: '/stop' },
-    { method: 'post', path: '/once' },
-    { method: 'get', path: '/log' },
-  ],
-  '/admin/base/log': [
-    { method: 'post', path: '/clear' },
-    { method: 'post', path: '/setKeep' },
-    { method: 'post', path: '/getKeep' },
-  ],
-  '/admin/base/dict/info': [
-    { method: 'get', path: '/types' },
-    { method: 'post', path: '/data' },
-    { method: 'post', path: '/get' },
-    { method: 'post', path: '/find' },
-    { method: 'post', path: '/getValues' },
-    { method: 'post', path: '/pathValue' },
-    { method: 'post', path: '/childValue' },
-  ],
-  '/admin/base/module': [{ method: 'post', path: '/install' }],
-  '/admin/base/comm': [{ method: 'post', path: '/upload' }],
-  '/admin/user/info': [
-    { method: 'get', path: '/roles' },
-    { method: 'get', path: '/roleMap' },
-    { method: 'post', path: '/setRoles' },
-  ],
-}
-
-const FALLBACK_PREFIXES = [
-  '/admin/base/menu',
-  '/admin/base/user',
-  '/admin/base/role',
-  '/admin/base/department',
-  '/admin/base/tenant',
-  '/admin/base/task',
-  '/admin/base/log',
-  '/admin/base/plugin',
-  '/admin/base/dict/info',
-  '/admin/base/dict/type',
-  '/admin/base/module',
-  '/admin/base/comm',
-  '/admin/user/info',
-  '/admin/user/role',
-]
-
-function toCamel(str: string) {
-  return str.replace(/([^-])(?:-+([^-]))/g, (_m, a, b) => a + String(b).toUpperCase())
-}
-
-function methodName(path: string) {
-  return path.replace(/^\//, '').replace(/[:,\s/-]/g, '')
-}
-
-function isValidName(name: string) {
-  return Boolean(name) && !['{', '}', ':'].some((c) => name.includes(c))
-}
-
-function resolvePermCode(prefix: string, action: string) {
-  const parts = prefix.replace(/^\//, '').split('/').filter(Boolean)
-  const module = parts[1] || parts[0] || 'base'
-  let resource = parts.slice(2).join(':')
-  if (resource === module) {
-    resource = module
-  } else if (resource.startsWith(`${module}:`)) {
-    resource = resource.slice(module.length + 1)
-  }
-  const head = `${module}-`
-  if (resource.startsWith(head)) resource = resource.slice(head.length)
-  resource = resource.replace(/-/g, ':')
-  if (!resource) resource = module
-  return `${module}:${resource}:${action}`
-}
-
-function prefixToParts(prefix: string) {
-  const raw = prefix.replace(/^\//, '')
-  return raw
-    .replace(new RegExp(`^${SIDE_ID}/?`), '')
-    .split('/')
-    .filter(Boolean)
-    .map(toCamel)
-}
-
-function bindCrud(leaf: ServiceLeaf, base: BaseService) {
-  const proto = BaseService.prototype as unknown as Record<string, unknown>
-  for (const name of [
-    'request',
-    'page',
-    'list',
-    'info',
-    'add',
-    'update',
-    'delete',
-    'restore',
-  ]) {
-    const fn = proto[name]
-    if (typeof fn === 'function') {
-      ;(leaf as Record<string, unknown>)[name] = (
-        fn as (...a: unknown[]) => unknown
-      ).bind(base)
-    }
-  }
-}
-
-function bindApis(leaf: ServiceLeaf, base: BaseService, apis: EpsApiItem[]) {
-  leaf.permission ||= {}
-  for (const api of apis) {
-    const name = methodName(api.path)
-    if (!isValidName(name) || /[-:]/g.test(name)) continue
-    const method = (api.method || 'get').toLowerCase()
-    ;(leaf as Record<string, unknown>)[name] = function (
-      this: BaseService,
-      data?: unknown,
-    ) {
-      return this.request({
-        url: api.path.startsWith('/') ? api.path : `/${api.path}`,
-        method,
-        [method === 'post' ? 'data' : 'params']: data,
-      })
-    }.bind(base)
-    leaf.permission[name] =
-      api.perms?.[0] || resolvePermCode(`/${leaf.namespace}`, name)
-  }
-}
-
-/** 原地重挂方法，保持叶子对象引用不变（避免页面 const log = service.base.log 失效） */
-function remountLeaf(leaf: ServiceLeaf, namespace: string, apis: EpsApiItem[]) {
-  const ns = namespace.replace(/^\//, '')
-  const base = new BaseService(ns)
-  leaf.namespace = ns
-  leaf.permission = {}
-  leaf._permission = leaf._permission || {}
-
-  // 清掉旧方法再绑，避免残留错误实现
-  for (const key of Object.keys(leaf as object)) {
-    if (
-      key === 'namespace' ||
-      key === 'permission' ||
-      key === '_permission' ||
-      key === 'search'
-    ) {
-      continue
-    }
-    delete (leaf as Record<string, unknown>)[key]
-  }
-
-  bindCrud(leaf, base)
-  bindApis(leaf, base, apis)
-
-  for (const name of Object.keys(leaf.permission)) {
-    if (leaf._permission[name] == null) leaf._permission[name] = false
-  }
-  return leaf
-}
-
-function createLeaf(namespace: string, apis: EpsApiItem[] = []): ServiceLeaf {
-  const ns = namespace.replace(/^\//, '')
-  const base = new BaseService(ns)
-  const leaf = base as unknown as ServiceLeaf
-  leaf.namespace = ns
-  leaf.permission = {}
-  leaf._permission = {}
-  bindCrud(leaf, base)
-  bindApis(leaf, base, apis)
-  return leaf
-}
-
-function attachLeaf(
-  tree: ServiceTree | Eps.Service,
-  prefix: string,
-  apis: EpsApiItem[] = [],
-) {
-  const raw = prefix.replace(/^\//, '')
-  const arr = prefixToParts(prefix)
-  if (!arr.length) return undefined
-
-  let node: Record<string, unknown> = tree as unknown as Record<string, unknown>
-  for (let i = 0; i < arr.length; i++) {
-    const key = arr[i]!
-    const isLast = i === arr.length - 1
-    if (!isLast) {
-      const cur = node[key] as ServiceLeaf | Record<string, unknown> | undefined
-      // 中间节点若被误建成叶子，换成容器（否则 dict/info 挂不上）
-      if (!cur || typeof cur !== 'object' || 'namespace' in cur) {
-        node[key] = {}
-      }
-      node = node[key] as Record<string, unknown>
-      continue
-    }
-
-    const existing = node[key] as ServiceLeaf | undefined
-    if (existing && typeof existing === 'object' && existing.namespace) {
-      return remountLeaf(existing, raw, apis)
-    }
-    const leaf = createLeaf(raw, apis)
-    node[key] = leaf
-    return leaf
-  }
-  return undefined
-}
-
-function buildFromEps(map: EpsModuleMap) {
-  const list = Object.values(map).flat() as EpsEntity[]
-  for (const e of list) {
-    if (!e.prefix) continue
-    const leaf = attachLeaf(service, e.prefix, e.api || [])
-    if (leaf) {
-      const op = (e as { pageQueryOp?: Record<string, unknown> }).pageQueryOp
-      if (op) {
-        ;(leaf as ServiceLeaf & { search?: unknown }).search = {
-          fieldEq: op.fieldEq,
-          fieldLike: op.fieldLike,
-          fieldArray: op.fieldArray,
-          fieldRange: op.fieldRange,
-          keyWordLikeFields: op.keyWordLikeFields,
-        }
-      }
-    }
-  }
-}
-
-function extraApisOf(prefix: string): EpsApiItem[] {
-  return (FALLBACK_EXTRA_APIS[prefix] || []).map(
-    (a) =>
-      ({
-        method: a.method,
-        path: a.path,
-        perms: a.perms,
-      }) as EpsApiItem,
-  )
-}
-
-/**
- * 用 fallback 补全：已有叶子则合并补方法（不整棵删，避免打断引用）。
- * 对 fallback 前缀：若 EPS 已挂过，只补缺失的 extra；attachLeaf/remount 会重绑整叶。
- */
-function buildFallback() {
-  for (const prefix of FALLBACK_PREFIXES) {
-    const parts = prefixToParts(prefix)
-    let node: Record<string, unknown> = service as unknown as Record<string, unknown>
-    let missing = false
-    for (let i = 0; i < parts.length; i++) {
-      const key = parts[i]!
-      if (!node[key]) {
-        missing = true
-        break
-      }
-      if (i < parts.length - 1) {
-        node = node[key] as Record<string, unknown>
-      }
-    }
-    const leaf = missing
-      ? undefined
-      : (node[parts[parts.length - 1]!] as ServiceLeaf | undefined)
-
-    if (leaf?.namespace) {
-      // 只补 extra 里还没有的方法，保留 EPS 已绑方法
-      const extras = extraApisOf(prefix).filter((api) => {
-        const name = methodName(api.path)
-        return typeof (leaf as Record<string, unknown>)[name] !== 'function'
-      })
-      if (extras.length) {
-        const base = new BaseService(leaf.namespace)
-        bindApis(leaf, base, extras)
-      }
-      continue
-    }
-    attachLeaf(service, prefix, extraApisOf(prefix))
-  }
-}
-
-type ServiceRoot = Eps.Service & { request: BaseService['request'] }
-
-const g = globalThis as typeof globalThis & {
-  __vome_admin_service__?: ServiceRoot
-  __vome_admin_service_build__?: number
-}
-
-function createServiceRoot(): ServiceRoot {
-  const root = new BaseService()
-  return {
-    request: root.request.bind(root),
-  } as ServiceRoot
-}
-
-function getOrCreateRoot(): ServiceRoot {
-  if (
-    !g.__vome_admin_service__ ||
-    g.__vome_admin_service_build__ !== SERVICE_BUILD
-  ) {
-    g.__vome_admin_service__ = createServiceRoot()
-    g.__vome_admin_service_build__ = SERVICE_BUILD
-  }
-  return g.__vome_admin_service__
-}
-
-/** 全局链式 service（service.base.user.page()） */
-export const service: ServiceRoot = getOrCreateRoot()
-
-buildFallback()
-
-/** 从 EPS 构建/刷新；再 fallback 补自定义方法 */
-export async function createEps(force = false) {
-  try {
-    const map = (await loadEps(force)) || {}
-    if (Object.keys(map).length) buildFromEps(map)
-  } catch (e) {
-    console.warn('[vome-eps] load failed', e)
-  }
-  buildFallback()
-  return service
-}
-
-if (import.meta.hot) {
-  import.meta.hot.on('eps-update', () => {
-    void createEps(true).then(() => {
-      if (import.meta.env.DEV) console.log('[vome-eps] service hot updated')
-    })
-  })
-}
-
-export function setServicePerms(perms: string[], isSuper = false) {
-  const list = perms || []
-
-  function deep(d: unknown) {
-    if (!d || typeof d !== 'object') return
-    const obj = d as ServiceLeaf & Record<string, unknown>
-    if (obj.permission && obj.namespace) {
-      obj._permission = {}
-      for (const key of Object.keys(obj.permission)) {
-        if (isSuper) {
-          obj._permission[key] = true
-          continue
-        }
-        const code = obj.permission[key]
-        obj._permission[key] =
-          list.includes(code) ||
-          list.some((p) =>
-            p
-              .replace(/:/g, '/')
-              .includes(`${obj.namespace.replace(/^admin\//, '')}/${key}`),
-          )
-      }
-      return
-    }
-    for (const k of Object.keys(obj)) {
-      if (k === 'request') continue
-      deep(obj[k])
-    }
-  }
-
-  deep(service)
-}
-
-export function resolveService(path: string): ServiceLeaf | undefined {
-  const parts = path.replace(/^\//, '').split('.').filter(Boolean)
-  let cur: unknown = service
-  for (const p of parts) {
-    if (!cur || typeof cur !== 'object') return undefined
-    cur = (cur as Record<string, unknown>)[p]
-  }
-  if (cur && typeof cur === 'object' && 'namespace' in (cur as object)) {
-    return cur as ServiceLeaf
-  }
-  return undefined
-}
-
-export function serviceOf(prefix: string): ServiceLeaf {
-  const raw = prefix.replace(/\/$/, '')
-  const path = prefixToParts(raw).join('.')
-  const hit = resolveService(path)
-  if (hit) return hit
-  return attachLeaf(service, raw, extraApisOf(raw.startsWith('/') ? raw : `/${raw}`)) as ServiceLeaf
-}
-
-/** @deprecated 请用 service.base.xxx */
-export function createEpsService(prefix: string) {
-  return serviceOf(prefix)
-}
-
-export { BaseService }
-export type { ServiceLeaf, ServiceTree } from '../../../typings/admin/comm/service'

package/src/admin/stores/app.ts

@@ -1,30 +0,0 @@
-import { defineStore } from 'pinia'
-import { nextTick } from 'vue'
-
-const FOLD_KEY = 'vome_admin_sidebar_fold'
-
-export const useAppStore = defineStore('app', {
-  state: () => ({
-    /** 桌面端手动折叠侧栏 */
-    sidebarFold: localStorage.getItem(FOLD_KEY) === '1',
-    /** 移动端抽屉开合 */
-    mobileOpen: false,
-    /** 为 false 时卸掉 RouterView，用于「刷新当前页」 */
-    viewAlive: true,
-  }),
-  actions: {
-    toggleSidebarFold() {
-      this.sidebarFold = !this.sidebarFold
-      localStorage.setItem(FOLD_KEY, this.sidebarFold ? '1' : '0')
-    },
-    setMobileOpen(open: boolean) {
-      this.mobileOpen = open
-    },
-    /** 重挂载当前视图（非浏览器整页刷新） */
-    async reloadView() {
-      this.viewAlive = false
-      await nextTick()
-      this.viewAlive = true
-    },
-  },
-})