adspecs 0.1.12

package/references/antd-front-demo/src/router/dynamicRoutes.tsx

@@ -0,0 +1,179 @@
+import type { MenuRecord } from '@/types/auth';
+import type { MenuProps } from 'antd';
+import type { RouteObject } from 'react-router';
+import { lazy, Suspense } from 'react';
+import { Spin } from 'antd';
+import Icon from '@/components/Icon';
+
+type AntMenuItem = NonNullable<MenuProps['items']>[number];
+
+// ── Component loader using Vite glob import ─────────────────────
+
+const pages = import.meta.glob('@/pages/**/index.{tsx,jsx}');
+
+function loadComponent(componentPath: string) {
+  if (!componentPath) return null;
+  const tsxKey = `/src/pages/${componentPath}.tsx`;
+  const jsxKey = `/src/pages/${componentPath}.jsx`;
+  const loader = (pages as Record<string, unknown>)[tsxKey] ?? (pages as Record<string, unknown>)[jsxKey];
+  if (!loader) return null;
+  return lazy(loader as () => Promise<{ default: React.ComponentType }>);
+}
+
+// ── Icon helper ─────────────────────────────────────────────────
+
+function getIcon(iconName?: string): React.ReactNode {
+  if (!iconName) return undefined;
+  return <Icon icon={iconName} />;
+}
+
+// ── Menu UI items (for sidebar) ─────────────────────────────────
+
+export function menusToMenuItems(menus: MenuRecord[]): AntMenuItem[] {
+  return menus
+    .filter((m) => m.type !== 3 && m.status === 0 && m.visible)
+    .sort((a, b) => a.sort - b.sort)
+    .map((menu): AntMenuItem => {
+      const children = menu.children?.length
+        ? menusToMenuItems(menu.children)
+        : undefined;
+      if (children?.length) {
+        return {
+          key: menu.path,
+          icon: getIcon(menu.icon),
+          label: menu.name,
+          children,
+        };
+      }
+      return {
+        key: menu.path,
+        icon: getIcon(menu.icon),
+        label: menu.name,
+      };
+    });
+}
+
+// ── Menu → Route conversion ─────────────────────────────────────
+
+/**
+ * Flatten all type=2 menu items to a flat list.
+ * This avoids the double-path nesting bug where directory routes
+ * add their path prefix to children that already have full paths.
+ *
+ * Equivalent to Vue's flatMultiLevelRoutes(), but more aggressive:
+ * we flatten ALL levels instead of just collapsing depth > 2.
+ */
+function flatMenus(menus: MenuRecord[]): MenuRecord[] {
+  const result: MenuRecord[] = [];
+  function walk(items: MenuRecord[]) {
+    for (const m of items) {
+      if (m.visible === false) {
+        m.canTo = true;
+      }
+      if (m.type === 2 && m.component) {
+        result.push(m);
+      }
+      if (m.children?.length) walk(m.children);
+    }
+  }
+  walk(menus);
+  return result;
+}
+
+function menuToRoute(menu: MenuRecord): RouteObject | null {
+  // Skip external links
+  if (menu.path.startsWith('http://') || menu.path.startsWith('https://')) {
+    return null;
+  }
+
+  const routePath = menu.path.startsWith('/')
+    ? menu.path.slice(1)
+    : menu.path;
+
+  const LazyComponent = loadComponent(menu.component);
+  if (!LazyComponent) return null;
+
+  return {
+    id: `menu-${menu.id}`,
+    path: routePath,
+    element: (
+      <Suspense
+        fallback={
+          <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100vh' }}>
+            <Spin size="large" />
+          </div>
+        }
+      >
+        <LazyComponent />
+      </Suspense>
+    ),
+  };
+}
+
+/**
+ * 将菜单数据转换为路由配置
+ * 1. 仅转换 type=2 且 status=0 的菜单项
+ * 2. 路径前缀 '/' 会被移除（因为路由是相对于父路径的）
+ * 3. 使用 Suspense 包裹组件，显示全屏加载状态
+ * 4. 外部链接（http:// 或 https://）会被忽略，不生成路由
+ * 5. 组件路径通过 Vite 的 glob 导入动态加载
+ */
+export function menusToRoutes(menus: MenuRecord[]): RouteObject[] {
+  return flatMenus(menus)
+    .filter((m) => m.status === 0)
+    .sort((a, b) => a.sort - b.sort)
+    .map((menu) => menuToRoute(menu))
+    .filter((r): r is RouteObject => r !== null);
+}
+
+// ── Open keys & breadcrumbs ─────────────────────────────────────
+
+export function findOpenKeys(
+  path: string,
+  menus: MenuRecord[],
+  parents: string[] = [],
+): string[] {
+  for (const menu of menus) {
+    if (menu.path === path) return parents;
+    if (menu.children?.length) {
+      const found = findOpenKeys(path, menu.children, [
+        ...parents,
+        menu.path,
+      ]);
+      if (found.length) return found;
+    }
+  }
+  return [];
+}
+
+export function findBreadcrumb(
+  path: string,
+  menus: MenuRecord[],
+  trail: { title: string }[] = [],
+): { title: string }[] {
+  for (const menu of menus) {
+    if (menu.path === path) return [...trail, { title: menu.name }];
+    if (menu.children?.length) {
+      const found = findBreadcrumb(path, menu.children, [
+        ...trail,
+        { title: menu.name },
+      ]);
+      if (found.length > trail.length + 1) return found;
+    }
+  }
+  return trail;
+}
+
+export function findActiveMenuMeta(
+  path: string,
+  menus: MenuRecord[],
+): string | null {
+  for (const menu of menus) {
+    if (menu.path === path) return menu.activeMenu ?? null;
+    if (menu.children?.length) {
+      const found = findActiveMenuMeta(path, menu.children);
+      if (found) return found;
+    }
+  }
+  return null;
+}

package/references/antd-front-demo/src/router/index.tsx

@@ -0,0 +1,105 @@
+import { lazy, Suspense } from 'react';
+import { createBrowserRouter, Navigate, type RouteObject } from 'react-router';
+import { Spin } from 'antd';
+import type { MenuRecord } from '@/types/auth';
+import AuthGuard from './authGuard';
+import { menusToRoutes } from './dynamicRoutes';
+
+// eslint-disable-next-line react-refresh/only-export-components
+const AdminLayout = lazy(() => import('@/layouts/AdminLayout'));
+// eslint-disable-next-line react-refresh/only-export-components
+const LoginPage = lazy(() => import('@/pages/login'));
+// eslint-disable-next-line react-refresh/only-export-components
+const ProfilePage = lazy(() => import('@/pages/profile'));
+// eslint-disable-next-line react-refresh/only-export-components
+const DashboardPage = lazy(() => import('@/pages/dashboard'));
+// eslint-disable-next-line react-refresh/only-export-components
+const NotFound = lazy(() => import('@/pages/error/404'));
+
+// eslint-disable-next-line react-refresh/only-export-components
+const LazyLoad: React.FC<{ children: React.ReactNode }> = ({ children }) => (
+  <Suspense fallback={<div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100vh' }}><Spin size="large" /></div>}>
+    {children}
+  </Suspense>
+);
+
+// Static children of admin route (not from menus)
+// These are always available: default redirect, profile, 404
+const adminStaticChildren: RouteObject[] = [
+  { index: true, element: <Navigate to="/dashboard" replace /> },
+  {
+    path: 'dashboard',
+    element: <LazyLoad><DashboardPage /></LazyLoad>,
+  },
+  {
+    path: 'profile',
+    element: <LazyLoad><ProfilePage /></LazyLoad>,
+  },
+  // Catch-all 404
+  { path: '*', element: <LazyLoad><NotFound /></LazyLoad> },
+];
+
+export const router = createBrowserRouter([
+  {
+    path: '/login',
+    element: <LazyLoad><LoginPage /></LazyLoad>,
+  },
+  {
+    id: 'admin',
+    path: '/',
+    element: (
+      <AuthGuard>
+        <LazyLoad><AdminLayout /></LazyLoad>
+      </AuthGuard>
+    ),
+    children: adminStaticChildren,
+    errorElement: <LazyLoad><NotFound /></LazyLoad>,
+  },
+]);
+
+/** Dashboard static menu item — injected as the first sidebar entry */
+const STATIC_MENU: MenuRecord = {
+  id: -1,
+  parentId: 0,
+  name: '工作台',
+  path: '/dashboard',
+  component: 'dashboard',
+  icon: 'ep:house',
+  type: 2,
+  sort: 0,
+  status: 0,
+  visible: true,
+  keepAlive: true,
+};
+
+/**
+ * Inject dynamic routes from backend menus into the admin layout.
+ * Prepend a static "工作台" dashboard menu, return the merged menus
+ * so the caller can store them correctly.
+ */
+export function addDynamicRoutes(menus: MenuRecord[]): MenuRecord[] {
+  const mergedMenus = [STATIC_MENU, ...menus];
+  const dynamicRoutes = menusToRoutes(mergedMenus);
+  router.patchRoutes('admin', [...adminStaticChildren, ...dynamicRoutes]);
+
+  // Only force re-match when the current URL is under the admin layout
+  // and matched to the catch-all 404 (e.g., page refresh before routes existed).
+  const { pathname } = router.state.location;
+  const isLogin = pathname === '/login';
+  const is404 = router.state.matches.some(
+    (m) => m.route.path === '*',
+  );
+  if (!isLogin && is404) {
+    router.navigate(pathname, { replace: true });
+  }
+
+  return mergedMenus;
+}
+
+/**
+ * Remove dynamic routes (called on logout).
+ * Resets admin children back to static-only.
+ */
+export function resetDynamicRoutes() {
+  router.patchRoutes('admin', adminStaticChildren);
+}

package/references/antd-front-demo/src/setupTests.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/references/antd-front-demo/src/stores/useAppStore.ts

@@ -0,0 +1,43 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import i18n from '@/i18n';
+
+interface AppState {
+  collapsed: boolean;
+  darkMode: boolean;
+  language: string;
+  primaryColor: string;
+  componentSize: 'small' | 'middle' | 'large';
+  menuTheme: 'dark' | 'light';
+  toggleCollapsed: () => void;
+  toggleDarkMode: () => void;
+  setLanguage: (lang: string) => void;
+  setPrimaryColor: (color: string) => void;
+  setComponentSize: (size: 'small' | 'middle' | 'large') => void;
+  setMenuTheme: (theme: 'dark' | 'light') => void;
+}
+
+export const useAppStore = create<AppState>()(
+  persist(
+    (set) => ({
+      collapsed: false,
+      darkMode: false,
+      language: localStorage.getItem('app-language') || 'zh-CN',
+      primaryColor: '#1677ff',
+      componentSize: 'middle' as const,
+      menuTheme: 'dark' as const,
+      toggleCollapsed: () => set((s) => ({ collapsed: !s.collapsed })),
+      toggleDarkMode: () => set((s) => ({ darkMode: !s.darkMode })),
+      setLanguage: (lang: string) => {
+        i18n.changeLanguage(lang);
+        localStorage.setItem('app-language', lang);
+        set({ language: lang });
+      },
+      setPrimaryColor: (color: string) => set({ primaryColor: color }),
+      setComponentSize: (size: 'small' | 'middle' | 'large') =>
+        set({ componentSize: size }),
+      setMenuTheme: (theme: 'dark' | 'light') => set({ menuTheme: theme }),
+    }),
+    { name: 'admin-pro-app' },
+  ),
+);

package/references/antd-front-demo/src/stores/useAuthStore.ts

@@ -0,0 +1,78 @@
+import { create } from 'zustand';
+import { getAccessToken, setToken, removeToken } from '@/utils/token';
+import { scheduleProactiveRefresh, clearProactiveRefresh } from '@/utils/request';
+import { loginApi, logoutApi, getAuthPermissionInfoApi } from '@/api/auth';
+import type { UserInfo, MenuRecord, LoginParams } from '@/types/auth';
+import { convertBackendMenus } from '@/utils/menuConverter';
+import { addDynamicRoutes, resetDynamicRoutes } from '@/router';
+
+interface AuthState {
+  token: string | null;
+  userInfo: UserInfo | null;
+  roles: string[];
+  permissions: string[];
+  menus: MenuRecord[];
+  login: (params: LoginParams, remember?: boolean) => Promise<void>;
+  logout: () => Promise<void>;
+  fetchPermissionInfo: () => Promise<void>;
+  hasPermission: (code: string) => boolean;
+  reset: () => void;
+}
+
+export const useAuthStore = create<AuthState>()((set, get) => ({
+  token: getAccessToken(),
+  userInfo: null,
+  roles: [],
+  permissions: [],
+  menus: [],
+
+  login: async (params, remember = true) => {
+    const { data } = await loginApi(params);
+    setToken(data.accessToken, data.refreshToken, remember, data.expiresTime);
+    set({ token: data.accessToken });
+    scheduleProactiveRefresh();
+    await get().fetchPermissionInfo();
+  },
+
+  logout: async () => {
+    try {
+      await logoutApi();
+    } finally {
+      get().reset();
+    }
+  },
+
+  fetchPermissionInfo: async () => {
+    const resp = await getAuthPermissionInfoApi();
+    if (!resp || !resp.data) {
+      throw new Error('Failed to fetch permission info: empty response');
+    }
+    const { data } = resp;
+    const menus = convertBackendMenus(data.menus ?? []);
+    const mergedMenus = addDynamicRoutes(menus);
+    set({
+      userInfo: data.user,
+      roles: data.roles ?? [],
+      permissions: data.permissions ?? [],
+      menus: mergedMenus,
+    });
+  },
+
+  hasPermission: (code) => {
+    const perms = get().permissions;
+    return perms.includes('*:*:*') || perms.includes(code);
+  },
+
+  reset: () => {
+    clearProactiveRefresh();
+    resetDynamicRoutes();
+    removeToken();
+    set({
+      token: null,
+      userInfo: null,
+      roles: [],
+      permissions: [],
+      menus: [],
+    });
+  },
+}));

package/references/antd-front-demo/src/stores/useDictStore.ts

@@ -0,0 +1,41 @@
+import { create } from 'zustand';
+import { getSimpleDictDataList, type DictData } from '@/api/system/dict-data';
+
+interface DictState {
+  dictMap: Map<string, DictData[]>;
+  isLoaded: boolean;
+  fetchDictData: () => Promise<void>;
+  getDictOptions: (type: string) => DictData[];
+  getDictLabel: (type: string, value: string | number) => string;
+}
+
+export const useDictStore = create<DictState>()((set, get) => ({
+  dictMap: new Map(),
+  isLoaded: false,
+
+  fetchDictData: async () => {
+    if (get().isLoaded) return;
+    try {
+      const { data } = await getSimpleDictDataList();
+      const map = new Map<string, DictData[]>();
+      for (const item of data) {
+        const list = map.get(item.dictType) || [];
+        list.push(item);
+        map.set(item.dictType, list);
+      }
+      set({ dictMap: map, isLoaded: true });
+    } catch {
+      // silently fail
+    }
+  },
+
+  getDictOptions: (type) => {
+    return get().dictMap.get(type) || [];
+  },
+
+  getDictLabel: (type, value) => {
+    const options = get().dictMap.get(type) || [];
+    const item = options.find((d) => String(d.value) === String(value));
+    return item?.label || String(value);
+  },
+}));

package/references/antd-front-demo/src/types/api.ts

@@ -0,0 +1,17 @@
+export interface ApiResponse<T = unknown> {
+  code: number;
+  message: string;
+  data: T;
+}
+
+export interface PageParams {
+  pageNo: number;
+  pageSize: number;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any;
+}
+
+export interface PageResult<T> {
+  list: T[];
+  total: number;
+}

package/references/antd-front-demo/src/types/aps/coil.ts

@@ -0,0 +1,42 @@
+// APS 母卷类型定义
+
+export interface CoilVO {
+  id: number;
+  coilId: string;
+  alloy: string;
+  temper: string;
+  width: number;
+  thickness: number;
+  weight: number;
+  inDate: string;
+  status: number;
+  createTime: string;
+}
+
+export interface CoilSaveParams {
+  id?: number;
+  coilId: string;
+  alloy: string;
+  temper: string;
+  width: number;
+  thickness: number;
+  weight: number;
+  inDate: string;
+  status?: number;
+}
+
+export interface CoilPageParams {
+  pageNo: number;
+  pageSize: number;
+  coilId?: string;
+  alloy?: string;
+  status?: number;
+}
+
+// 母卷状态枚举
+export const COIL_STATUS = {
+  0: { label: '待裁剪', color: 'default' },
+  1: { label: '裁剪中', color: 'processing' },
+  2: { label: '已裁剪', color: 'success' },
+  3: { label: '已报废', color: 'error' },
+} as const;

package/references/antd-front-demo/src/types/aps/order.ts

@@ -0,0 +1,63 @@
+// APS 订单类型定义
+
+export interface OrderVO {
+  id: number;
+  orderId: string;
+  customerName: string;
+  alloy: string;
+  temper: string;
+  thickness: number;
+  width: number;
+  innerDiameter: number;
+  minOuterDiameter: number;
+  maxOuterDiameter: number;
+  demand: number;
+  deliveryDate: string;
+  priority: number;
+  status: number;
+  assigned?: number;
+  createTime: string;
+}
+
+export interface OrderSaveParams {
+  id?: number;
+  orderId: string;
+  customerName: string;
+  alloy: string;
+  temper: string;
+  thickness: number;
+  width: number;
+  innerDiameter: number;
+  minOuterDiameter: number;
+  maxOuterDiameter: number;
+  demand: number;
+  deliveryDate: string;
+  priority: number;
+  status?: number;
+}
+
+export interface OrderPageParams {
+  pageNo: number;
+  pageSize: number;
+  orderId?: string;
+  customerName?: string;
+  status?: number;
+  priority?: number;
+}
+
+// 订单状态枚举
+export const ORDER_STATUS = {
+  0: { label: '待分配', color: 'default' },
+  1: { label: '部分分配', color: 'processing' },
+  2: { label: '已完成', color: 'success' },
+  3: { label: '已取消', color: 'error' },
+} as const;
+
+// 优先级枚举
+export const ORDER_PRIORITY = {
+  1: { label: '低', color: 'default' },
+  2: { label: '中低', color: 'processing' },
+  3: { label: '中', color: 'warning' },
+  4: { label: '中高', color: 'orange' },
+  5: { label: '高', color: 'error' },
+} as const;

package/references/antd-front-demo/src/types/aps/param.ts

@@ -0,0 +1,48 @@
+// APS 工艺参数类型定义
+
+export interface ProcessParamVO {
+  id: number;
+  paramName: string;
+  paramValue: string;
+  paramUnit: string;
+  description: string;
+  updateTime: string;
+}
+
+export interface ProcessParamSaveParams {
+  id?: number;
+  paramName: string;
+  paramValue: string;
+  paramUnit: string;
+  description: string;
+}
+
+// 参数名称常量
+export const PARAM_NAMES = {
+  EDGE_WASTE_WIDTH: 'edgeWasteWidth', // 废边宽度 A
+  HEAD_TAIL_WASTE: 'headTailWaste', // 废头尾长度 B
+  CUT_HEAD_LENGTH: 'cutHeadLength', // 切头长度 h
+  MAX_VERTICAL_CUTS: 'maxVerticalCuts', // 最大竖切刀数 G
+  MAX_HORIZONTAL_CUTS: 'maxHorizontalCuts', // 最大横切刀数 P
+  MIN_ORDER_WIDTH: 'minOrderWidth', // 最小订单宽度
+  UTILIZATION_WEIGHT: 'utilizationWeight', // 利用率权重
+  PRIORITY_WEIGHT: 'priorityWeight', // 优先级权重
+  CUTS_WEIGHT: 'cutsWeight', // 切割刀数权重
+  MIN_REGION_LENGTH: 'minRegionLength', // 最小区域长度
+  MAX_ORDER_SPLIT: 'maxOrderSplit', // 最大订单拆分次数
+} as const;
+
+// 默认参数值
+export const DEFAULT_PARAMS: Record<string, { value: string; unit: string; description: string }> = {
+  [PARAM_NAMES.EDGE_WASTE_WIDTH]: { value: '10', unit: 'mm', description: '母卷左右两侧各需裁掉的废边宽度' },
+  [PARAM_NAMES.HEAD_TAIL_WASTE]: { value: '1000', unit: 'mm', description: '母卷卷头卷尾各需裁掉的废料长度' },
+  [PARAM_NAMES.CUT_HEAD_LENGTH]: { value: '200', unit: 'mm', description: '每次横切后新区域开端的固定切除长度' },
+  [PARAM_NAMES.MAX_VERTICAL_CUTS]: { value: '12', unit: '刀', description: '每区域竖切刀数上限' },
+  [PARAM_NAMES.MAX_HORIZONTAL_CUTS]: { value: '5', unit: '刀', description: '横切刀数上限（区域数-1）' },
+  [PARAM_NAMES.MIN_ORDER_WIDTH]: { value: '100', unit: 'mm', description: '最小可交付订单宽度' },
+  [PARAM_NAMES.UTILIZATION_WEIGHT]: { value: '0.5', unit: '', description: '全局优化目标中利用率权重' },
+  [PARAM_NAMES.PRIORITY_WEIGHT]: { value: '0.3', unit: '', description: '全局优化目标中优先级加权满足率权重' },
+  [PARAM_NAMES.CUTS_WEIGHT]: { value: '0.2', unit: '', description: '全局优化目标中切割刀数权重' },
+  [PARAM_NAMES.MIN_REGION_LENGTH]: { value: '500', unit: 'mm', description: '长度小于该值的区域不生成' },
+  [PARAM_NAMES.MAX_ORDER_SPLIT]: { value: '1', unit: '次', description: '每个订单最多允许拆分次数' },
+};

package/references/antd-front-demo/src/types/aps/plan.ts

@@ -0,0 +1,59 @@
+// APS 裁剪方案类型定义
+
+export interface CuttingPlanVO {
+  planId: string;
+  coilId: string;
+  coilAlloy?: string;
+  coilTemper?: string;
+  coilWidth?: number;
+  coilWeight?: number;
+  verticalCuts: string; // 格式: "10,310,610;10,400,800"
+  horizontalCuts: string; // 格式: "101000,333568"
+  totalCuts: number;
+  theoreticalUtilization: number;
+  score: number;
+  createTime: string;
+}
+
+export interface SmallCoilVO {
+  smallCoilId: string;
+  planId: string;
+  width: number;
+  length: number;
+  weight: number;
+  outerDiameter: number;
+  orderId?: string;
+  region: number;
+}
+
+export interface PlanDetailVO extends CuttingPlanVO {
+  smallCoils: SmallCoilVO[];
+}
+
+export interface PlanPageParams {
+  pageNo: number;
+  pageSize: number;
+  coilId?: string;
+  planId?: string;
+}
+
+// 切割方案可视化数据结构
+export interface CuttingVisualizationData {
+  coilWidth: number;
+  coilLength: number;
+  edgeWasteWidth: number;
+  regions: RegionData[];
+}
+
+export interface RegionData {
+  regionId: number;
+  length: number;
+  startY: number;
+  strips: StripData[];
+}
+
+export interface StripData {
+  width: number;
+  orderId?: string;
+  orderColor?: string;
+}