v-nuxt-ui 0.2.24 → 0.2.26

package/dist/runtime/composables/form/useForm.d.ts

@@ -0,0 +1,21 @@
+import { type Ref, type MaybeRefOrGetter } from 'vue';
+import type { ApiGroup, BaseModel, VFormFieldProps } from '#v/types';
+import type { ConfirmDiffItem } from '#v/components/form/save-model-template/ConfirmUpdateModal.vue';
+export declare const useFormValues: <T>(raw: Ref<T>, defaultValues?: Partial<T>) => {
+    oldValues: Ref<T>;
+    newValues: Ref<T>;
+};
+export declare const useFormSubmission: <T extends BaseModel>(oldValues: Ref<T>, newValues: Ref<T>, close: (ok: boolean) => void, save: (model: T) => void, apiGroup: () => ApiGroup<T>, arrayTypeFieldKeys?: (keyof T)[], rowKey?: keyof T, versionKey?: keyof T, getExtraFields?: () => Record<string, any>) => {
+    onSubmit: () => Promise<void>;
+};
+export declare const useConfirmDiff: (fields: MaybeRefOrGetter<VFormFieldProps[]>, diffItems: MaybeRefOrGetter<ConfirmDiffItem[]>, oldModelValue: MaybeRefOrGetter<Record<string, unknown>>, newModelValue: MaybeRefOrGetter<Record<string, unknown>>) => {
+    diffedItems: import("vue").ComputedRef<{
+        oldDisplay: string;
+        newDisplay: string;
+        parts: import("diff").ChangeObject<string>[];
+        field: VFormFieldProps | undefined;
+        fieldName: string;
+        oldValue: unknown;
+        newValue: unknown;
+    }[]>;
+};

package/dist/runtime/composables/{useForm.js → form/useForm.js}

@@ -1,6 +1,7 @@
-import { ref, watch } from "vue";
+import { ref, watch, computed, toValue } from "vue";
 import { defu } from "defu";
 import { getObjWithModifiedFields } from "#v/utils";
+import { resolveDisplayValue, smartDiff } from "#v/composables";
 import { useToast } from "@nuxt/ui/composables";
 export const useFormValues = (raw, defaultValues) => {
   const oldValues = ref({});
@@ -62,3 +63,24 @@ export const useFormSubmission = (oldValues, newValues, close, save, apiGroup, a
   }
   return { onSubmit };
 };
+export const useConfirmDiff = (fields, diffItems, oldModelValue, newModelValue) => {
+  const resolvedItems = computed(
+    () => toValue(diffItems).map((item) => ({
+      ...item,
+      field: toValue(fields).find((f) => f.name === item.fieldName)
+    })).filter((item) => item.field != null)
+  );
+  const diffedItems = computed(
+    () => resolvedItems.value.map((item) => {
+      const oldDisplay = resolveDisplayValue(item.field, item.oldValue, toValue(oldModelValue));
+      const newDisplay = resolveDisplayValue(item.field, item.newValue, toValue(newModelValue));
+      return {
+        ...item,
+        oldDisplay,
+        newDisplay,
+        parts: smartDiff(oldDisplay, newDisplay)
+      };
+    })
+  );
+  return { diffedItems };
+};

package/dist/runtime/composables/form/useFormUpdate.d.ts

@@ -0,0 +1,6 @@
+import type { VFormFieldProps } from '#v/types';
+export declare function resolveSelectLabel(rawVal: unknown, items: readonly any[]): string;
+export declare function resolveDisplayValue(field: VFormFieldProps, rawVal: unknown, modelSource: Record<string, unknown>): string;
+export declare function smartDiff(oldStr: string, newStr: string): import("diff").ChangeObject<string>[];
+export declare const diffEligibleTypes: Set<string>;
+export declare function formatValue(val: unknown): string;

package/dist/runtime/composables/form/useFormUpdate.js

@@ -0,0 +1,101 @@
+import dayjs from "dayjs";
+import { diffWords, diffChars } from "diff";
+import { dateFormat } from "#v/constants";
+export function resolveSelectLabel(rawVal, items) {
+  if (Array.isArray(rawVal)) {
+    return rawVal.map((v) => items.find((i) => i?.value === v)?.label ?? String(v)).join(", ") || "";
+  }
+  return items.find((i) => i?.value === rawVal)?.label ?? String(rawVal);
+}
+export function resolveDisplayValue(field, rawVal, modelSource) {
+  if (rawVal === null || rawVal === void 0) return "";
+  switch (field.type) {
+    case "switch":
+    case "button-switch":
+      return rawVal ? "\u662F" : "\u5426";
+    case "date-picker": {
+      if (typeof rawVal === "string") {
+        const d = dayjs(rawVal);
+        if (d.isValid()) return d.format(dateFormat);
+      }
+      return String(rawVal);
+    }
+    case "select": {
+      const items = field.enableEmptyOption ? [{ label: "\u65E0", value: 0 }, ...field.items ?? []] : field.items ?? [];
+      return resolveSelectLabel(rawVal, items);
+    }
+    case "multiple-select-string":
+    case "radio-select":
+      return resolveSelectLabel(rawVal, field.items ?? []);
+    case "async-select":
+    case "async-tree-select":
+    case "async-object-select": {
+      if (!field.name) return String(rawVal);
+      if (rawVal === 0) return "";
+      const labelField = field.labelField;
+      if (!labelField) return String(rawVal);
+      let model;
+      for (const v of Object.values(modelSource)) {
+        if (v && typeof v === "object" && v[labelField] !== void 0) {
+          if (String(v.id) === String(rawVal)) {
+            model = v;
+            break;
+          }
+        }
+      }
+      if (!model) {
+        model = field.initModel;
+      }
+      if (!model) return String(rawVal);
+      if (Array.isArray(model)) {
+        return model.map((m) => m && typeof m === "object" ? String(m[labelField] ?? "") : String(m)).filter(Boolean).join(", ") || "";
+      }
+      if (typeof model === "object") {
+        const label = model[labelField];
+        if (label != null) return String(label);
+      }
+      return String(rawVal);
+    }
+    case "input-string-number": {
+      const v = rawVal === 0 ? "0" : String(rawVal);
+      const trailing = field.trailingString;
+      return trailing ? `${v} ${trailing}` : v;
+    }
+    case "tree-select-transfer": {
+      if (Array.isArray(rawVal)) {
+        return rawVal.map((item) => {
+          if (item && typeof item === "object") {
+            const obj = item;
+            return String(obj.label ?? obj.name ?? "");
+          }
+          return String(item);
+        }).filter(Boolean).join(", ") || "";
+      }
+      return formatValue(rawVal);
+    }
+    default:
+      return formatValue(rawVal);
+  }
+}
+export function smartDiff(oldStr, newStr) {
+  if (!oldStr.includes(" ") && !newStr.includes(" ")) {
+    return diffChars(oldStr, newStr);
+  }
+  return diffWords(oldStr, newStr);
+}
+export const diffEligibleTypes = /* @__PURE__ */ new Set([
+  "input",
+  "dynamic-input",
+  "input-string-number",
+  "input-number",
+  "textarea",
+  "input-pwd",
+  "sql-editor",
+  "date-picker"
+]);
+export function formatValue(val) {
+  if (val === null || val === void 0) return "";
+  if (typeof val === "boolean") return val ? "\u662F" : "\u5426";
+  if (typeof val === "object") return JSON.stringify(val);
+  return String(val);
+}

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

@@ -5,7 +5,7 @@ export * from './useApp.js';
 export * from './useBoolean.js';
 export * from './useDate.js';
 export * from './useEChart.js';
-export * from './useForm.js';
+export * from './form/index.js';
 export * from './useTheme.js';
 export * from './useSidebarMenu.js';
 export * from './usePermission.js';

package/dist/runtime/composables/index.js

@@ -5,7 +5,7 @@ export * from "./useApp.js";
 export * from "./useBoolean.js";
 export * from "./useDate.js";
 export * from "./useEChart.js";
-export * from "./useForm.js";
+export * from "./form/index.js";
 export * from "./useTheme.js";
 export * from "./useSidebarMenu.js";
 export * from "./usePermission.js";

package/dist/runtime/composables/table/useTable.js

@@ -44,7 +44,8 @@ export function useTable(props) {
     disableRowSelection,
     expandable,
     rowSpanColumns,
-    customRowCopyFn
+    customRowCopyFn,
+    displayFnInDeleteModal
   } = props;
   const queryComposable = useTableQuery({
     name,
@@ -96,6 +97,9 @@ export function useTable(props) {
   } = dataComposable;
   const rowSelectionComposable = useTableRowSelection(data, rowKey);
   const { rowSelection, selectedIds, clearRowSelection: _clearRowSelection } = rowSelectionComposable;
+  const selectedModels = computed(
+    () => data.value.filter((row) => selectedIds.value.includes(row[rowKey]))
+  );
   const whereQueryRef = useTemplateRef("proTableQueryWhere");
   const onFilterClick = (field) => {
     whereQueryOpen.value = true;
@@ -149,6 +153,8 @@ export function useTable(props) {
   } = columnsComposable;
   const rowActionsComposable = useTableRowActions({
     rowKey,
+    tableName: name,
+    bizColumns,
     disableRowActions,
     disableRowUpdate,
     disableRowCopy,
@@ -157,6 +163,7 @@ export function useTable(props) {
     extraRowActions,
     useApiGroup,
     customRowCopyFn,
+    displayFnInDeleteModal,
     fetchList
   });
   const { getRowActions, generateActionColumn } = rowActionsComposable;
@@ -287,6 +294,8 @@ export function useTable(props) {
     fetchList,
     onEditRowFromModal,
     selectedIds: selectedIds.value,
+    selectedModels: selectedModels.value,
+    displayFnInDeleteModal,
     disableCreation,
     disableWhereQuery,
     whereQueryProps: tblWhereQueryProps.value,

package/dist/runtime/composables/table/useTableRowActions.d.ts

@@ -2,6 +2,8 @@ import type { VColumn } from '#v/types';
 import type { DropdownMenuItem, TableRow } from '@nuxt/ui';
 export declare function useTableRowActions<T>(props: {
     rowKey: keyof T;
+    tableName?: string;
+    bizColumns?: VColumn<T>[];
     disableRowActions?: boolean;
     disableRowUpdate?: boolean;
     disableRowCopy?: boolean;
@@ -10,6 +12,7 @@ export declare function useTableRowActions<T>(props: {
     extraRowActions?: any[];
     useApiGroup?: (...args: any[]) => any;
     customRowCopyFn?: (...args: any[]) => any;
+    displayFnInDeleteModal?: (model: T) => string | undefined;
     fetchList: () => Promise<void>;
 }): {
     getRowActions: (row: TableRow<T>) => DropdownMenuItem[];

package/dist/runtime/composables/table/useTableRowActions.js

@@ -1,11 +1,14 @@
 import { ref, h } from "vue";
 import { useOverlay } from "@nuxt/ui/composables";
 import DeleteModal from "#v/components/DeleteModal.vue";
+import UpdateDiffModal from "#v/components/table/UpdateDiffModal.vue";
 import UDropdownMenu from "@nuxt/ui/components/DropdownMenu.vue";
 import UButton from "@nuxt/ui/components/Button.vue";
 export function useTableRowActions(props) {
   const {
     rowKey,
+    tableName,
+    bizColumns,
     disableRowActions: _disableRowActions,
     disableRowUpdate,
     disableRowCopy,
@@ -14,10 +17,12 @@ export function useTableRowActions(props) {
     extraRowActions,
     useApiGroup,
     customRowCopyFn,
+    displayFnInDeleteModal,
     fetchList
   } = props;
   const overlay = useOverlay();
   const deleteModal = overlay.create(DeleteModal);
+  const updateDiffModal = overlay.create(UpdateDiffModal);
   const apiGroup = useApiGroup?.();
   const actionLoadingRowIdxSet = ref(/* @__PURE__ */ new Set());
   function getRowActions(row) {
@@ -89,6 +94,23 @@ export function useTableRowActions(props) {
     extraRowActions?.forEach((action) => {
       actionItems.push(buildActionItem(action));
     });
+    if (tableName) {
+      if (actionItems.length > 0 && !disableRowDeletion) {
+        actionItems.push({ type: "separator" });
+      }
+      actionItems.push({
+        label: "\u53D8\u66F4\u8BB0\u5F55",
+        icon: "i-lucide-history",
+        onClick: () => {
+          updateDiffModal.open({
+            tableName,
+            rowId: row.original[rowKey],
+            columns: bizColumns || [],
+            title: "\u53D8\u66F4\u8BB0\u5F55"
+          });
+        }
+      });
+    }
     if (!disableRowDeletion) {
       if (actionItems.length > 0) {
         actionItems.push({ type: "separator" });
@@ -100,6 +122,8 @@ export function useTableRowActions(props) {
         onSelect: async () => {
           const result = await deleteModal.open({
             ids: [row.original[rowKey]],
+            models: [row.original],
+            displayFn: displayFnInDeleteModal,
             onDelete: (ids) => apiGroup?.batchDelete({ ids })
           }).result;
           if (result) {

package/dist/runtime/composables/useDate.js

@@ -40,6 +40,8 @@ const _useDate = () => {
       }
       case "day":
         return date.format("YYYY-MM-DD");
+      case "time":
+        return date.format("YYYY-MM-DD HH:mm:ss");
       default:
         throw new Error(`Unsupported time unit: ${unit}`);
     }

package/dist/runtime/types/components/form/field.d.ts

@@ -33,6 +33,8 @@ export type VFormFieldProps = FormFieldProps & {
     placeholder?: string;
     annotation?: string;
     enterKeydownSubmit?: boolean;
+    /** 在确认修改弹窗中是否使用逐词 diff 高亮 */
+    diffable?: boolean;
 } & ({
     type: 'separator';
     separatorLabel?: string;

package/dist/runtime/types/components/form/index.d.ts

@@ -8,20 +8,21 @@ export type FormTemplateProps<T> = {
     onUpdateModelValue?: (newVal: Partial<T>) => void;
     onTriggerSubmit?: (e: Event) => void;
 };
-export type CreateModalFormTemplateProps<T> = {
+export type SaveModalFormTemplateProps<T> = {
     title: string;
     description?: string;
     onClose: (ok: boolean) => void;
     onSubmit: () => Promise<void>;
     fields: VFormFieldProps[];
+    oldModelValue: Partial<T>;
     modelValue: Partial<T>;
     onUpdateModelValue?: (newVal: Partial<T>) => void;
     rowKey?: keyof T;
     fullscreen?: ModalProps['fullscreen'];
 };
-export type CreateModalFormTemplatePropsWithApi<T> = {
+export type SaveModalFormTemplatePropsWithApi<T> = {
     apiGroup: () => ApiGroup<T>;
     valuePruneFn?: (value: T) => T;
     defaultModelValue?: Partial<T>;
     onSave: (model: T) => void;
-} & Pick<CreateModalFormTemplateProps<T>, 'title' | 'description' | 'fields' | 'onClose' | 'modelValue' | 'onUpdateModelValue'>;
+} & Pick<SaveModalFormTemplateProps<T>, 'title' | 'description' | 'fields' | 'onClose' | 'modelValue' | 'onUpdateModelValue'>;

package/dist/runtime/types/components/table/header.d.ts

@@ -13,6 +13,8 @@ export type TableHeaderProps<T> = {
     fetchList: () => Promise<void>;
     onEditRowFromModal?: (row: T) => Promise<boolean>;
     selectedIds?: number[];
+    selectedModels?: T[];
+    displayFnInDeleteModal?: (model: T) => string | undefined;
     disableCreation?: boolean;
     disableWhereQuery?: boolean;
     whereQueryProps: WhereQueryProps<T>;

package/dist/runtime/types/components/table/index.d.ts

@@ -102,4 +102,5 @@ export type VTableProps<T> = {
     expandVNode?: (row: T) => VNode;
     rowSpanColumns?: (keyof T)[];
     customRowCopyFn?: (model: T) => T;
+    displayFnInDeleteModal?: (model: T) => string | undefined;
 };

package/dist/runtime/types/time.d.ts

@@ -1,4 +1,4 @@
-export type TimeUnit = 'day' | 'week' | 'month' | 'quarter' | 'year';
+export type TimeUnit = 'day' | 'week' | 'month' | 'quarter' | 'year' | 'time';
 export declare enum CalendarEventType {
     NONE = 0,
     HOLIDAY = 1,

package/dist/runtime/utils/cron.d.ts

@@ -0,0 +1 @@
+export declare const cronToCn: (val: string | undefined | null, tzOffset?: number) => string | null;

package/dist/runtime/utils/cron.js

@@ -0,0 +1,182 @@
+const WEEKDAY_CN = ["\u65E5", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D"];
+function pad(v) {
+  return String(v).padStart(2, "0");
+}
+function parseFields(cron) {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+  return {
+    minute: parts[0],
+    hour: parts[1],
+    dayOfMonth: parts[2],
+    month: parts[3],
+    dayOfWeek: parts[4]
+  };
+}
+function validateField(val, min, max) {
+  if (val === "*" || val === "?") return true;
+  const segments = val.split(",");
+  for (const seg of segments) {
+    const stepIdx = seg.indexOf("/");
+    const base = stepIdx >= 0 ? seg.slice(0, stepIdx) : seg;
+    const step = stepIdx >= 0 ? Number(seg.slice(stepIdx + 1)) : 1;
+    if (step < 1) return false;
+    if (base === "*") continue;
+    const dashIdx = base.indexOf("-");
+    if (dashIdx >= 0) {
+      const lo = Number(base.slice(0, dashIdx));
+      const hi = Number(base.slice(dashIdx + 1));
+      if (isNaN(lo) || isNaN(hi)) return false;
+      if (lo < min || lo > max || hi < min || hi > max || lo > hi) return false;
+    } else {
+      const n = Number(base);
+      if (isNaN(n) || n < min || n > max) return false;
+    }
+  }
+  return true;
+}
+function validateCron(fields) {
+  return validateField(fields.minute, 0, 59) && validateField(fields.hour, 0, 23) && validateField(fields.dayOfMonth, 1, 31) && validateField(fields.month, 1, 12) && validateField(fields.dayOfWeek, 0, 7);
+}
+function isSimpleNumber(val) {
+  return /^\d+$/.test(val);
+}
+function shiftDow(val, shift) {
+  return val.split(",").map((v) => {
+    const dashIdx = v.indexOf("-");
+    if (dashIdx >= 0) {
+      const lo = Number(v.slice(0, dashIdx));
+      const hi = Number(v.slice(dashIdx + 1));
+      const loNorm = lo === 7 ? 0 : lo;
+      const hiNorm = hi === 7 ? 0 : hi;
+      return `${(loNorm + shift) % 7}-${(hiNorm + shift) % 7}`;
+    }
+    const n = v === "7" ? 0 : Number(v);
+    return String((n + shift) % 7);
+  }).join(",");
+}
+function shiftDom(val, shift) {
+  return val.split(",").map((v) => {
+    const dashIdx = v.indexOf("-");
+    if (dashIdx >= 0) {
+      const lo = Number(v.slice(0, dashIdx));
+      const hi = Number(v.slice(dashIdx + 1));
+      return `${lo + shift}-${hi + shift}`;
+    }
+    return String(Number(v) + shift);
+  }).join(",");
+}
+function applyTzOffset(fields, offset) {
+  const result = { ...fields };
+  if (fields.hour === "*") return result;
+  if (!isSimpleNumber(fields.hour)) {
+    return result;
+  }
+  const hour = Number(fields.hour);
+  const newHour = (hour + offset) % 24;
+  const dayShift = hour + offset >= 24 ? 1 : hour + offset < 0 ? -1 : 0;
+  result.hour = String(newHour);
+  if (dayShift > 0) {
+    if (fields.dayOfWeek !== "*" && fields.dayOfWeek !== "?") {
+      result.dayOfWeek = shiftDow(fields.dayOfWeek, dayShift);
+    }
+    if (fields.dayOfMonth !== "*" && fields.dayOfMonth !== "?" && !fields.dayOfMonth.includes("L") && !fields.dayOfMonth.includes("W")) {
+      result.dayOfMonth = shiftDom(fields.dayOfMonth, dayShift);
+    }
+  }
+  return result;
+}
+function isWildcard(v) {
+  return v === "*" || v === "?";
+}
+function describeMinute(minute) {
+  if (isWildcard(minute)) return "\u6BCF\u5206\u949F";
+  if (minute.startsWith("*/")) {
+    return `\u6BCF${minute.slice(2)}\u5206\u949F`;
+  }
+  return "";
+}
+function describeHour(hour) {
+  if (isWildcard(hour)) return "";
+  if (hour.includes(",")) {
+    return hour.split(",").map((h) => `${h}\u70B9`).join("\u3001");
+  }
+  if (hour.includes("-")) {
+    const [lo, hi] = hour.split("-");
+    return `${lo}\u70B9\u81F3${hi}\u70B9`;
+  }
+  return `${hour}\u70B9`;
+}
+function describeDayOfWeek(dayOfWeek) {
+  if (isWildcard(dayOfWeek) || dayOfWeek === "?") return "";
+  if (dayOfWeek.includes(",")) {
+    const days = dayOfWeek.split(",").map((d) => {
+      const n = Number(d);
+      return `\u5468${WEEKDAY_CN[n]}`;
+    }).join("\u3001");
+    return `\u6BCF${days}`;
+  }
+  if (dayOfWeek.includes("-")) {
+    const [lo, hi] = dayOfWeek.split("-");
+    return `\u6BCF\u5468${WEEKDAY_CN[Number(lo)]}\u81F3\u5468${WEEKDAY_CN[Number(hi)]}`;
+  }
+  return `\u6BCF\u5468${WEEKDAY_CN[Number(dayOfWeek)]}`;
+}
+function describeDayOfMonth(dayOfMonth) {
+  if (isWildcard(dayOfMonth) || dayOfMonth === "?") return "";
+  if (dayOfMonth.includes(",")) {
+    return "\u6BCF\u6708" + dayOfMonth.split(",").map((d) => `${d}\u65E5`).join("\u3001");
+  }
+  if (dayOfMonth.includes("-")) {
+    const [lo, hi] = dayOfMonth.split("-");
+    return `\u6BCF\u6708${lo}\u65E5\u81F3${hi}\u65E5`;
+  }
+  if (dayOfMonth.startsWith("*/")) {
+    return `\u6BCF${dayOfMonth.slice(2)}\u65E5`;
+  }
+  return `\u6BCF\u6708${dayOfMonth}\u65E5`;
+}
+function describeMonth(month) {
+  if (isWildcard(month)) return "";
+  if (month.includes(",")) {
+    return month.split(",").map((m) => `${m}\u6708`).join("\u3001");
+  }
+  return `${month}\u6708`;
+}
+function toChinese(fields) {
+  const minDesc = describeMinute(fields.minute);
+  const hourDesc = describeHour(fields.hour);
+  const dowDesc = describeDayOfWeek(fields.dayOfWeek);
+  const domDesc = describeDayOfMonth(fields.dayOfMonth);
+  const monthDesc = describeMonth(fields.month);
+  if (minDesc && isWildcard(fields.hour) && isWildcard(fields.dayOfMonth) && isWildcard(fields.month) && isWildcard(fields.dayOfWeek)) {
+    return minDesc;
+  }
+  if (!hourDesc) return "\u65E0\u6548\u8868\u8FBE\u5F0F";
+  const scheduleParts = [];
+  if (monthDesc) scheduleParts.push(monthDesc);
+  if (domDesc) scheduleParts.push(domDesc);
+  if (dowDesc) {
+    scheduleParts.push(dowDesc);
+  }
+  let timeStr;
+  if (fields.minute === "0") {
+    timeStr = hourDesc;
+  } else if (isWildcard(fields.minute)) {
+    timeStr = `${hourDesc}\u6BCF\u5206\u949F`;
+  } else {
+    timeStr = `${hourDesc}:${pad(Number(fields.minute))}`;
+  }
+  if (scheduleParts.length === 0) {
+    return `\u6BCF\u5929 ${timeStr}`;
+  }
+  return `${scheduleParts.join(" ")} ${timeStr}`;
+}
+export const cronToCn = (val, tzOffset = 8) => {
+  if (!val?.trim()) return null;
+  const fields = parseFields(val);
+  if (!fields) return null;
+  if (!validateCron(fields)) return null;
+  const localFields = applyTzOffset(fields, tzOffset);
+  return toChinese(localFields);
+};

package/dist/runtime/utils/index.d.ts

@@ -9,3 +9,4 @@ export * from './string.js';
 export * from './tree.js';
 export * from './type.js';
 export * from './vueuse.js';
+export * from './cron.js';

package/dist/runtime/utils/index.js

@@ -9,3 +9,4 @@ export * from "./string.js";
 export * from "./tree.js";
 export * from "./type.js";
 export * from "./vueuse.js";
+export * from "./cron.js";

package/dist/runtime/utils/vueuse.d.ts

@@ -1 +1 @@
-export declare const useCnTimeAgo: (time: string | Date) => import("vue").ComputedRef<string>;
+export declare const useCnTimeAgo: (time: string | Date | undefined) => "" | import("vue").ComputedRef<string>;

package/dist/runtime/utils/vueuse.js

@@ -1,5 +1,6 @@
 import { useTimeAgo } from "@vueuse/core";
 export const useCnTimeAgo = (time) => {
+  if (!time) return "";
   return useTimeAgo(time, {
     messages: {
       justNow: "\u521A\u521A",