v-nuxt-ui 0.1.0

package/dist/runtime/composables/useEChart.js

@@ -0,0 +1,120 @@
+import { createSharedComposable } from "@vueuse/core";
+import { defu } from "defu";
+import { useApp } from "./useApp.js";
+import { useTheme } from "./useTheme.js";
+import { triggerFileDownloadFromUrl } from "#v/utils";
+const _useEChart = () => {
+  const app = useApp();
+  const theme = useTheme();
+  const parseCSSVariableColor = (colorStr) => {
+    if (!colorStr?.startsWith("var(")) return colorStr;
+    const varName = colorStr.match(/var\((--[^,)]+)/)?.[1];
+    if (!varName) return colorStr;
+    const value = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+    return value || colorStr;
+  };
+  const getNormedUiTextColor = () => parseCSSVariableColor("var(--ui-text-muted)");
+  const getNormedUiBorderColor = () => parseCSSVariableColor("var(--ui-border)");
+  const getNormedRadius = () => Math.round((app.appConfig.value.radius ?? 0.25) * 16);
+  const getNormedChartColors = () => theme.chartColorVars.value.map((colorVar) => parseCSSVariableColor(colorVar));
+  const getCommonGridOption = () => ({
+    grid: { left: "0", right: "0", bottom: "32", top: "20", containLabel: true }
+  });
+  const getCommonLegendOption = () => ({
+    legend: {
+      show: true,
+      bottom: "0",
+      itemGap: 12,
+      itemWidth: 12,
+      itemHeight: 12,
+      textStyle: { color: getNormedUiTextColor() },
+      icon: "circle"
+    }
+  });
+  const getCommonXAxisOption = () => ({
+    color: getNormedChartColors(),
+    xAxis: {
+      nameTextStyle: { color: getNormedUiTextColor() },
+      axisLine: { show: true, lineStyle: { color: getNormedUiBorderColor() } },
+      axisLabel: { color: getNormedUiTextColor(), interval: () => true, hideOverlap: true },
+      axisTick: { show: true, interval: () => true, lineStyle: { color: getNormedUiBorderColor() } }
+    }
+  });
+  const getCommonYAxisOption = () => ({
+    yAxis: {
+      nameTextStyle: { color: getNormedUiTextColor() },
+      axisLine: { show: true, lineStyle: { color: getNormedUiBorderColor() } },
+      axisLabel: { color: getNormedUiTextColor() },
+      splitLine: { show: false, lineStyle: { color: getNormedUiBorderColor(), type: "dashed" } }
+    }
+  });
+  const getCommonBarOption = () => ({
+    itemStyle: { borderRadius: [getNormedRadius(), getNormedRadius(), 0, 0] },
+    emphasis: { focus: "series" },
+    label: { color: getNormedUiTextColor(), distance: 2 }
+  });
+  const getCommonBarOptionWithColor = (idx) => {
+    const colors = getNormedChartColors();
+    return defu(getCommonBarOption(), { emphasis: { itemStyle: { color: colors[idx] } } });
+  };
+  const getCommonLineOption = () => ({
+    emphasis: { focus: "series" },
+    label: { color: getNormedUiTextColor(), distance: 2 }
+  });
+  const getCommonLineOptionWithColor = (idx) => {
+    const colors = getNormedChartColors();
+    return defu(getCommonLineOption(), {
+      emphasis: { lineStyle: { color: colors[idx] } },
+      lineStyle: { color: colors[idx] }
+    });
+  };
+  const getChartDataURL = (chart, options = {}) => {
+    if (!chart || typeof chart.getDataURL !== "function") return null;
+    const { type = "png", backgroundColor = "", pixelRatio = Math.max(1, window.devicePixelRatio || 1) } = options;
+    const echartsType = type === "jpg" ? "jpeg" : type;
+    try {
+      return chart.getDataURL({ type: echartsType, backgroundColor, pixelRatio });
+    } catch (e) {
+      console.error("Failed to get EChart dataURL:", e);
+      return null;
+    }
+  };
+  const exportChartAsImage = (chart, options = {}) => {
+    const { type = "png", backgroundColor = "", pixelRatio = Math.max(1, window.devicePixelRatio || 1), filename = "chart" } = options;
+    const dataURL = getChartDataURL(chart, { type, backgroundColor, pixelRatio });
+    if (!dataURL) return;
+    triggerFileDownloadFromUrl(dataURL, `${filename}.${type}`);
+  };
+  const mergeSeries = (series) => {
+    return series.map((s, seriesIndex) => {
+      if (s?.type === "bar") return defu(s, getCommonBarOptionWithColor(seriesIndex));
+      if (s?.type === "line") return defu(s, getCommonLineOptionWithColor(seriesIndex));
+      return s;
+    });
+  };
+  const mergeOption = (option) => {
+    const commonOption = defu(getCommonGridOption(), getCommonLegendOption(), getCommonXAxisOption(), getCommonYAxisOption());
+    const merged = defu(option, commonOption);
+    if (merged.yAxis && Array.isArray(merged.yAxis) && merged.yAxis.length > 1) {
+      const yAxisDefaults = getCommonYAxisOption().yAxis;
+      merged.yAxis = merged.yAxis.map((axis) => defu(axis, yAxisDefaults));
+    }
+    if (merged.series && Array.isArray(merged.series)) {
+      merged.series = mergeSeries(merged.series);
+    }
+    return merged;
+  };
+  return {
+    getCommonGridOption,
+    getCommonLegendOption,
+    getCommonXAxisOption,
+    getCommonYAxisOption,
+    getCommonBarOption,
+    getCommonLineOption,
+    mergeSeries,
+    mergeOption,
+    parseCSSVariableColor,
+    exportChartAsImage
+  };
+};
+export const useEChart = createSharedComposable(_useEChart);

package/dist/runtime/composables/useForm.js

@@ -0,0 +1,60 @@
+import { ref, watch } from "vue";
+import { defu } from "defu";
+import { getObjWithModifiedFields } from "#v/utils";
+import { useToast } from "@nuxt/ui/runtime/composables/useToast.js";
+export const useFormValues = (raw, defaultValues) => {
+  const oldValues = ref({});
+  const newValues = ref({});
+  watch(
+    raw,
+    (newRaw) => {
+      oldValues.value = { ...newRaw };
+      if (defaultValues) {
+        oldValues.value = defu(oldValues.value, defaultValues);
+      }
+      newValues.value = JSON.parse(JSON.stringify(oldValues.value));
+    },
+    { immediate: true }
+  );
+  return { oldValues, newValues };
+};
+export const useFormSubmission = (oldValues, newValues, close, save, apiGroup, arrayTypeFieldKeys = [], rowKey = "id", versionKey = "version") => {
+  const apiFns = apiGroup();
+  async function onSubmit() {
+    if (oldValues.value[rowKey] === 0) {
+      await onCreate();
+    } else {
+      await onUpdate();
+    }
+  }
+  async function onCreate() {
+    const { data } = await apiFns.create(apiFns.prune(newValues.value));
+    if (!data.value.error) {
+      save(data.value.data);
+      close(true);
+    }
+  }
+  async function onUpdate() {
+    const [objWithModifiedFields, modified] = getObjWithModifiedFields(
+      { id: oldValues.value[rowKey], version: oldValues.value[versionKey] },
+      oldValues.value,
+      newValues.value,
+      arrayTypeFieldKeys
+    );
+    if (!modified) {
+      useToast().add({
+        title: "Nothing changed",
+        description: "Please modify content before submitting",
+        color: "warning",
+        icon: "i-lucide-triangle-alert"
+      });
+      return;
+    }
+    const { data } = await apiFns.update(apiFns.prune(objWithModifiedFields));
+    if (!data.value.error) {
+      save(data.value.data);
+      close(true);
+    }
+  }
+  return { onSubmit };
+};

package/dist/runtime/composables/usePermission.d.ts

@@ -0,0 +1,10 @@
+export declare const _usePermission: () => {
+    setUserDynamicPermissions: (userRoles?: Model.Role[], userMenus?: Model.Menu[]) => void;
+    hasPermissions: (perms: string[] | string) => boolean;
+    hasAnyPermission: (perms: string[]) => boolean;
+};
+export declare const usePermission: () => {
+    setUserDynamicPermissions: (userRoles?: Model.Role[], userMenus?: Model.Menu[]) => void;
+    hasPermissions: (perms: string[] | string) => boolean;
+    hasAnyPermission: (perms: string[]) => boolean;
+};

package/dist/runtime/composables/usePermission.js

@@ -0,0 +1,53 @@
+import { createSharedComposable } from "@vueuse/core";
+import { useAuth } from "./useAuth.js";
+export const _usePermission = () => {
+  const { loginUserRoles, loginUserMenus } = useAuth();
+  const permissions = ref(/* @__PURE__ */ new Set());
+  const setUserDynamicPermissions = (userRoles = [], userMenus = []) => {
+    const allMenus = [];
+    userRoles.forEach((role) => {
+      if (role.menus?.length) {
+        allMenus.push(...role.menus);
+      }
+    });
+    if (userMenus.length) {
+      allMenus.push(...userMenus);
+    }
+    const permSet = /* @__PURE__ */ new Set();
+    const processedMenus = /* @__PURE__ */ new Set();
+    allMenus.forEach((menu) => {
+      if (!processedMenus.has(menu.id)) {
+        processedMenus.add(menu.id);
+        if (menu.permission?.trim()) {
+          permSet.add(menu.permission.trim());
+        }
+      }
+    });
+    permissions.value = permSet;
+  };
+  watch([loginUserRoles, loginUserMenus], ([newRoles, newMenus]) => {
+    setUserDynamicPermissions(newRoles, newMenus);
+  }, { immediate: true });
+  const hasPermissions = (perms) => {
+    if (!perms) return false;
+    if (typeof perms === "string") {
+      return permissions.value.has(perms.trim());
+    }
+    if (!Array.isArray(perms) || perms.length === 0) return false;
+    return perms.every(
+      (perm) => typeof perm === "string" && perm.trim() && permissions.value.has(perm.trim())
+    );
+  };
+  const hasAnyPermission = (perms) => {
+    if (!Array.isArray(perms) || perms.length === 0) return false;
+    return perms.some(
+      (perm) => typeof perm === "string" && perm.trim() && permissions.value.has(perm.trim())
+    );
+  };
+  return {
+    setUserDynamicPermissions,
+    hasPermissions,
+    hasAnyPermission
+  };
+};
+export const usePermission = createSharedComposable(_usePermission);

package/dist/runtime/composables/useRouterPush.d.ts

@@ -0,0 +1,8 @@
+import type { RouteLocationNormalizedLoadedGeneric } from 'vue-router';
+export declare function _useRouterPush(): {
+    toLogin: (route: RouteLocationNormalizedLoadedGeneric, redirectUrl?: string) => Promise<void>;
+    toHome: () => Promise<string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").NavigationFailure>;
+    toSecuritySettings: () => Promise<string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").NavigationFailure>;
+    redirectFromLogin: (route: RouteLocationNormalizedLoadedGeneric) => Promise<void>;
+};
+export declare const useRouterPush: typeof _useRouterPush;

package/dist/runtime/composables/useRouterPush.js

@@ -0,0 +1,37 @@
+import { LoginType } from "#v/constants";
+import { StorageKey } from "#v/types";
+import { createSharedComposable, useLocalStorage } from "@vueuse/core";
+import { navigateTo } from "nuxt/app";
+export function _useRouterPush() {
+  const toHome = async () => await navigateTo("/");
+  const toSecuritySettings = async () => await navigateTo("/settings/security");
+  const toLogin = async (route, redirectUrl) => {
+    useLocalStorage(StorageKey.ACCESS_TOKEN, "").value = void 0;
+    useLocalStorage(StorageKey.REFRESH_TOKEN, "").value = void 0;
+    let toLoginPage = "";
+    const localLoginType = useLocalStorage(StorageKey.LOGIN_TYPE, LoginType.USERNAME_PASSWORD);
+    switch (localLoginType.value) {
+      case LoginType.USERNAME_PASSWORD:
+        toLoginPage = "/login/pwd";
+        break;
+      default:
+        toLoginPage = "/login/pwd";
+    }
+    const redirect = redirectUrl || route.fullPath;
+    await navigateTo({ path: toLoginPage, query: { redirect } });
+  };
+  const redirectFromLogin = async (route) => {
+    const redirect = route.query?.redirect;
+    if (redirect)
+      await navigateTo(redirect);
+    else
+      toHome();
+  };
+  return {
+    toLogin,
+    toHome,
+    toSecuritySettings,
+    redirectFromLogin
+  };
+}
+export const useRouterPush = createSharedComposable(_useRouterPush);

package/dist/runtime/composables/useSidebarMenu.d.ts

@@ -0,0 +1,36 @@
+import type { BreadcrumbItem, NavigationMenuItem } from '@nuxt/ui';
+export declare function setGlobalSidebarMenus(opts: {
+    constantMenus?: NavigationMenuItem[];
+    bizMenus?: NavigationMenuItem[];
+    menuMode?: 'static' | 'dynamic';
+}): void;
+export declare const _useSidebarMenus: () => {
+    constantMenus: any;
+    constantMenuPathSet: any;
+    bizMenus: any;
+    flattenBizMenus: any;
+    bizMenuPathSet: any;
+    menusFromUser: any;
+    sidebarMenus: any;
+    sidebarMenuPathSet: any;
+    expandSidebarMenu: (path: string) => void;
+    setUserDynamicMenus: (newRolesFromUser: Model.Role[], newMenusFromUser: Model.Menu[]) => void;
+    disabledMenuPathSet: any;
+    breadcrumbs: any;
+    getBreadcrumbs: (current: string, menus?: NavigationMenuItem[]) => BreadcrumbItem[];
+};
+export declare const useSidebarMenus: () => {
+    constantMenus: any;
+    constantMenuPathSet: any;
+    bizMenus: any;
+    flattenBizMenus: any;
+    bizMenuPathSet: any;
+    menusFromUser: any;
+    sidebarMenus: any;
+    sidebarMenuPathSet: any;
+    expandSidebarMenu: (path: string) => void;
+    setUserDynamicMenus: (newRolesFromUser: Model.Role[], newMenusFromUser: Model.Menu[]) => void;
+    disabledMenuPathSet: any;
+    breadcrumbs: any;
+    getBreadcrumbs: (current: string, menus?: NavigationMenuItem[]) => BreadcrumbItem[];
+};

package/dist/runtime/composables/useSidebarMenu.js

@@ -0,0 +1,131 @@
+import { flattenTree } from "#v/utils";
+import { createSharedComposable } from "@vueuse/core";
+import { useAuth } from "./useAuth.js";
+const constantMenus = ref([]);
+const bizMenus = ref([]);
+const menuMode = ref("static");
+export function setGlobalSidebarMenus(opts) {
+  console.log("Setting global sidebar menus with options:", opts);
+  if (opts.constantMenus) constantMenus.value = opts.constantMenus;
+  if (opts.bizMenus) bizMenus.value = opts.bizMenus;
+  if (opts.menuMode) menuMode.value = opts.menuMode;
+}
+export const _useSidebarMenus = () => {
+  const { loginUserRoles, loginUserMenus } = useAuth();
+  const constantMenuPathSet = computed(() => {
+    const set = /* @__PURE__ */ new Set();
+    flattenTree(constantMenus.value).forEach((menu) => {
+      set.add(menu.to);
+    });
+    return set;
+  });
+  const flattenBizMenus = computed(() => flattenTree(bizMenus.value));
+  const bizMenuPathSet = computed(() => {
+    const set = /* @__PURE__ */ new Set();
+    flattenBizMenus.value.forEach((menu) => {
+      set.add(menu.to);
+    });
+    return set;
+  });
+  const menusFromUser = ref([]);
+  const sidebarMenus = ref([]);
+  const sidebarMenuPathSet = ref(/* @__PURE__ */ new Set());
+  const setUserDynamicMenus = (newRolesFromUser, newMenusFromUser) => {
+    sidebarMenuPathSet.value.clear();
+    menusFromUser.value = [...newMenusFromUser, ...newRolesFromUser.map((role) => role.menus ?? []).flat()];
+    menusFromUser.value.forEach((menu) => menu.staticRouteKeys?.forEach((key) => sidebarMenuPathSet.value.add(key)));
+    sidebarMenus.value = menuMode.value === "static" ? bizMenus.value : hideNoPermissionMenus(bizMenus.value, sidebarMenuPathSet.value);
+  };
+  watch([loginUserRoles, loginUserMenus, bizMenus], ([newRoles, newMenus]) => {
+    setUserDynamicMenus(newRoles, newMenus);
+    console.log(bizMenus.value.length, "123");
+  }, { immediate: true });
+  const expandSidebarMenu = (path) => {
+    const expandRecursively = (menus) => {
+      let found = false;
+      for (const menu of menus) {
+        if (menu.to === path) {
+          found = true;
+        } else if (menu.children) {
+          const childFound = expandRecursively(menu.children);
+          if (childFound) {
+            found = true;
+            menu.open = true;
+            menu.defaultOpen = true;
+          }
+        }
+      }
+      return found;
+    };
+    expandRecursively(sidebarMenus.value);
+  };
+  const hideNoPermissionMenus = (menuItems, paths) => {
+    return menuItems.filter((menuItem) => paths.has(menuItem.to) || paths.has(menuItem.triggerTo)).map((menuItem) => {
+      if (menuItem.children) {
+        return {
+          ...menuItem,
+          children: hideNoPermissionMenus(menuItem.children, paths)
+        };
+      }
+      return { ...menuItem };
+    });
+  };
+  const disabledMenuPathSet = computed(() => {
+    const set = /* @__PURE__ */ new Set();
+    flattenBizMenus.value.forEach((menu) => {
+      if (menu.disabled)
+        set.add(menu.to);
+    });
+    menusFromUser.value.forEach((menu) => {
+      if (menu.disabled && menu.staticRouteKeys)
+        menu.staticRouteKeys.forEach((key) => set.add(key));
+    });
+    return set;
+  });
+  const sidebarMenusAndConstantMenus = computed(() => {
+    const result = [];
+    result.push(...constantMenus.value);
+    result.push(...sidebarMenus.value);
+    return result;
+  });
+  const breadcrumbs = ref([]);
+  function getBreadcrumbs(current, menus = sidebarMenusAndConstantMenus.value) {
+    for (const menu of menus) {
+      if (menu.to === current) {
+        return [transformMenuToBreadcrumb(menu)];
+      }
+      if (menu.children) {
+        const result = getBreadcrumbs(current, menu.children);
+        if (result.length > 0) {
+          return [transformMenuToBreadcrumb(menu), ...result];
+        }
+      }
+    }
+    return [];
+  }
+  function transformMenuToBreadcrumb(menu) {
+    const { children, label, icon, to } = menu;
+    const breadcrumb = { label, icon, to };
+    if (children?.length) {
+      breadcrumb.children = children.map(transformMenuToBreadcrumb);
+    }
+    return breadcrumb;
+  }
+  return {
+    constantMenus,
+    constantMenuPathSet,
+    bizMenus,
+    flattenBizMenus,
+    bizMenuPathSet,
+    menusFromUser,
+    sidebarMenus,
+    sidebarMenuPathSet,
+    expandSidebarMenu,
+    setUserDynamicMenus,
+    disabledMenuPathSet,
+    // breadcrumb
+    breadcrumbs,
+    getBreadcrumbs
+  };
+};
+export const useSidebarMenus = createSharedComposable(_useSidebarMenus);

package/dist/runtime/composables/useTheme.d.ts

@@ -0,0 +1,20 @@
+import type { I18nLocale } from '#v/types';
+export declare const useTheme: () => {
+    blackAsPrimary: import("vue").WritableComputedRef<any, any>;
+    neutralColors: string[];
+    neutral: import("vue").WritableComputedRef<any, any>;
+    primaryColors: string[];
+    primary: import("vue").WritableComputedRef<any, any>;
+    chartColorVars: import("vue").ComputedRef<string[]>;
+    primaryColorVars: import("vue").ComputedRef<string[]>;
+    radiuses: number[];
+    radius: import("vue").WritableComputedRef<any, any>;
+    modes: import("vue").ComputedRef<{
+        label: string;
+        value: "light" | "dark" | "auto";
+        icon?: string;
+    }[]>;
+    mode: import("vue").WritableComputedRef<"light" | "dark" | "auto", "light" | "dark" | "auto">;
+    locale: import("vue").WritableComputedRef<I18nLocale, I18nLocale>;
+    locales: import("@nuxt/ui").Locale<import("@nuxt/ui").Messages>[];
+};

package/dist/runtime/composables/useTheme.js

@@ -0,0 +1,94 @@
+import { computed } from "vue";
+import { createSharedComposable, useColorMode } from "@vueuse/core";
+import colors from "tailwindcss/colors";
+import { omit } from "@nuxt/ui/utils";
+import { en, zh_cn } from "@nuxt/ui/locale";
+import { useApp } from "./useApp.js";
+import { useAppConfig } from "nuxt/app";
+const _useTheme = () => {
+  const appConfig = useAppConfig();
+  const colorMode = useColorMode();
+  const app = useApp();
+  const neutralColors = ["slate", "gray", "zinc", "neutral", "stone", "taupe", "mauve", "mist", "olive"];
+  const neutral = computed({
+    get() {
+      return appConfig.ui.colors.neutral;
+    },
+    set(option) {
+      console.log(option, appConfig);
+      appConfig.ui.colors.neutral = option;
+      app.updateNeutralColor(option);
+    }
+  });
+  const blackAsPrimary = computed({
+    get() {
+      return appConfig.theme.blackAsPrimary;
+    },
+    set(option) {
+      appConfig.theme.blackAsPrimary = option;
+      app.updateBlackAsPrimary(option);
+    }
+  });
+  const colorsToOmit = ["inherit", "current", "transparent", "black", "white", ...neutralColors];
+  const primaryColors = Object.keys(omit(colors, colorsToOmit));
+  const primary = computed({
+    get() {
+      return appConfig.ui.colors.primary;
+    },
+    set(option) {
+      appConfig.ui.colors.primary = option;
+      appConfig.theme.blackAsPrimary = false;
+      app.updatePrimaryColor(option);
+    }
+  });
+  const chartColorVars = computed(() => ["chart-1", "chart-2", "chart-3", "chart-4", "chart-5"].map((c) => `var(--${c})`));
+  const primaryColorVars = computed(() => primaryColors.map((c) => `var(--color-${c}-${colorMode.value === "light" ? "400" : "500"})`));
+  const radiuses = [0, 0.125, 0.25, 0.375, 0.5];
+  const radius = computed({
+    get() {
+      return appConfig.theme.radius;
+    },
+    set(option) {
+      appConfig.theme.radius = option;
+      app.updateRadius(option);
+    }
+  });
+  const modes = computed(() => [
+    { label: "\u660E\u4EAE\u6A21\u5F0F", value: "light", icon: appConfig.ui.icons.light },
+    { label: "\u6697\u9ED1\u6A21\u5F0F", value: "dark", icon: appConfig.ui.icons.dark },
+    { label: "\u8DDF\u968F\u7CFB\u7EDF", value: "auto", icon: appConfig.ui.icons.system }
+  ]);
+  const mode = computed({
+    get() {
+      return colorMode.value;
+    },
+    set(option) {
+      colorMode.value = option;
+    }
+  });
+  const locales = [zh_cn, en];
+  const locale = computed({
+    get() {
+      return app.appConfig.value.locale ?? "zh-CN";
+    },
+    set(value) {
+      app.updateLocale(value);
+    }
+  });
+  return {
+    blackAsPrimary,
+    neutralColors,
+    neutral,
+    primaryColors,
+    primary,
+    chartColorVars,
+    primaryColorVars,
+    radiuses,
+    radius,
+    modes,
+    mode,
+    locale,
+    locales
+  };
+};
+export const useTheme = createSharedComposable(_useTheme);

package/dist/runtime/constants/columns.d.ts

@@ -0,0 +1,3 @@
+import type { OrderQueryOpr, VColumn } from '#v/types';
+export declare const getCreateAtColumn: <T extends Model.BaseModel>(createdAtSortOpr?: OrderQueryOpr) => VColumn<T>;
+export declare const getOprColumns: <T extends Model.BaseModel>(createdAtSortOpr?: OrderQueryOpr) => VColumn<T>[];

package/dist/runtime/constants/columns.js

@@ -0,0 +1,52 @@
+import { useUserApi } from "#v/composables";
+import dayjs from "dayjs";
+import { dateTimeFormat } from "./time.js";
+export const getCreateAtColumn = (createdAtSortOpr = "desc") => ({
+  accessorKey: "createdAt",
+  header: "\u521B\u5EFA\u65F6\u95F4",
+  cell: ({ row }) => dayjs(row.original.createdAt).format(dateTimeFormat),
+  filterOption: {
+    type: "date-picker"
+  },
+  sortOption: {
+    defaultOpr: createdAtSortOpr
+  }
+});
+export const getOprColumns = (createdAtSortOpr = "desc") => [
+  {
+    accessorKey: "createdBy",
+    header: "\u521B\u5EFA\u4EBA",
+    cell: ({ row }) => row.original.creator?.nickname || "/",
+    filterOption: {
+      type: "async-select",
+      listApi: useUserApi().list,
+      searchFields: ["nickname"],
+      labelField: "nickname",
+      multiple: true,
+      defaultOpr: "in"
+    }
+  },
+  getCreateAtColumn(createdAtSortOpr),
+  {
+    accessorKey: "updatedBy",
+    header: "\u66F4\u65B0\u4EBA",
+    cell: ({ row }) => row.original.updater?.nickname || "/",
+    filterOption: {
+      type: "async-select",
+      listApi: useUserApi().list,
+      searchFields: ["nickname"],
+      labelField: "nickname",
+      multiple: true,
+      defaultOpr: "in"
+    }
+  },
+  {
+    accessorKey: "updatedAt",
+    header: "\u66F4\u65B0\u65F6\u95F4",
+    cell: ({ row }) => dayjs(row.original.updatedAt).format(dateTimeFormat),
+    filterOption: {
+      type: "date-picker"
+    },
+    sortOption: true
+  }
+];

package/dist/runtime/constants/flow.d.ts

@@ -0,0 +1,12 @@
+import { Position } from '@vue-flow/core';
+export type HandlePosition = 'tl' | 'tr' | 'bl' | 'br' | 't1' | 't2' | 't3' | 'r1' | 'r2' | 'r3' | 'b1' | 'b2' | 'b3' | 'l1' | 'l2' | 'l3';
+export type ResizeDirection = 'horizontal' | 'vertical' | 'both';
+export interface FlowHandle {
+    id: HandlePosition;
+    position: Position;
+    offsetPercent?: {
+        x?: number;
+        y?: number;
+    };
+}
+export declare const FLOW_HANDLES: FlowHandle[];

package/dist/runtime/constants/flow.js

@@ -0,0 +1,24 @@
+import { Position } from "@vue-flow/core";
+export const FLOW_HANDLES = [
+  // 4个角 - 可以双向调整
+  { id: "tl", position: Position.Top, offsetPercent: { x: 0 } },
+  { id: "tr", position: Position.Top, offsetPercent: { x: 100 } },
+  { id: "bl", position: Position.Bottom, offsetPercent: { x: 0 } },
+  { id: "br", position: Position.Bottom, offsetPercent: { x: 100 } },
+  // top边3个点 - 只能垂直调整
+  { id: "t1", position: Position.Top, offsetPercent: { x: 25 } },
+  { id: "t2", position: Position.Top, offsetPercent: { x: 50 } },
+  { id: "t3", position: Position.Top, offsetPercent: { x: 75 } },
+  // right边3个点 - 只能水平调整
+  { id: "r1", position: Position.Right, offsetPercent: { y: 25 } },
+  { id: "r2", position: Position.Right, offsetPercent: { y: 50 } },
+  { id: "r3", position: Position.Right, offsetPercent: { y: 75 } },
+  // bottom边3个点 - 只能垂直调整
+  { id: "b1", position: Position.Bottom, offsetPercent: { x: 25 } },
+  { id: "b2", position: Position.Bottom, offsetPercent: { x: 50 } },
+  { id: "b3", position: Position.Bottom, offsetPercent: { x: 75 } },
+  // left边3个点 - 只能水平调整
+  { id: "l1", position: Position.Left, offsetPercent: { y: 25 } },
+  { id: "l2", position: Position.Left, offsetPercent: { y: 50 } },
+  { id: "l3", position: Position.Left, offsetPercent: { y: 75 } }
+];