@kine-design/crud 0.0.1-beta.1

package/dist/crud.js

@@ -0,0 +1,3046 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { defineComponent, ref, watch, provide, createVNode, inject, computed, Fragment, Comment, createTextVNode, mergeProps, isRef, toRef, reactive, createApp, shallowRef, triggerRef, resolveComponent, h, onMounted, onBeforeUnmount, onUnmounted } from "vue";
+import { PaginationCore, usePagination } from "@kine-design/core";
+import { useQueryClient, useMutation, useQuery, QueryClient, VueQueryPlugin } from "@tanstack/vue-query";
+import { createPinia, defineStore } from "pinia";
+import { useRouter, useRoute } from "vue-router";
+const LAYOUT_COLLAPSED_KEY = Symbol("kCrudLayoutCollapsed");
+const LAYOUT_TOGGLE_KEY = Symbol("kCrudLayoutToggle");
+const LAYOUT_SIDER_WIDTH_KEY = Symbol("kCrudLayoutSiderWidth");
+const LAYOUT_COLLAPSED_WIDTH_KEY = Symbol("kCrudLayoutCollapsedWidth");
+const KLayout = /* @__PURE__ */ defineComponent({
+  name: "KLayout",
+  props: {
+    /** 受控模式：外部传入 collapsed 状态 */
+    collapsed: {
+      type: Boolean,
+      default: void 0
+    },
+    /** 侧边栏展开宽度 */
+    siderWidth: {
+      type: String,
+      default: "240px"
+    },
+    /** 侧边栏折叠宽度 */
+    collapsedWidth: {
+      type: String,
+      default: "64px"
+    }
+  },
+  emits: ["update:collapsed"],
+  setup(props2, ctx) {
+    const innerCollapsed = ref(props2.collapsed ?? false);
+    watch(() => props2.collapsed, (val) => {
+      if (val !== void 0) {
+        innerCollapsed.value = val;
+      }
+    });
+    const toggleCollapsed = () => {
+      const next = !innerCollapsed.value;
+      innerCollapsed.value = next;
+      ctx.emit("update:collapsed", next);
+    };
+    provide(LAYOUT_COLLAPSED_KEY, innerCollapsed);
+    provide(LAYOUT_TOGGLE_KEY, toggleCollapsed);
+    provide(LAYOUT_SIDER_WIDTH_KEY, props2.siderWidth);
+    provide(LAYOUT_COLLAPSED_WIDTH_KEY, props2.collapsedWidth);
+    return () => {
+      var _a, _b;
+      return createVNode("div", {
+        "class": "k-crud-layout"
+      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]);
+    };
+  }
+});
+const KSider = /* @__PURE__ */ defineComponent({
+  name: "KSider",
+  setup(_, ctx) {
+    const collapsed = inject(LAYOUT_COLLAPSED_KEY);
+    const toggle = inject(LAYOUT_TOGGLE_KEY);
+    const siderWidth = inject(LAYOUT_SIDER_WIDTH_KEY, "240px");
+    const collapsedWidth = inject(LAYOUT_COLLAPSED_WIDTH_KEY, "64px");
+    const currentWidth = computed(() => {
+      if (!collapsed) return siderWidth;
+      return collapsed.value ? collapsedWidth : siderWidth;
+    });
+    const isCollapsed = computed(() => (collapsed == null ? void 0 : collapsed.value) ?? false);
+    const handleTriggerClick = () => {
+      toggle == null ? void 0 : toggle();
+    };
+    const defaultTrigger = () => createVNode("button", {
+      "class": "k-crud-sider__trigger-btn",
+      "onClick": handleTriggerClick,
+      "title": isCollapsed.value ? "展开侧边栏" : "折叠侧边栏"
+    }, [createVNode("span", {
+      "class": ["k-crud-sider__trigger-icon", isCollapsed.value && "k-crud-sider__trigger-icon--collapsed"]
+    }, ["‹"])]);
+    return () => {
+      var _a, _b;
+      return createVNode("aside", {
+        "class": ["k-crud-sider", isCollapsed.value && "k-crud-sider--collapsed"],
+        "style": {
+          width: currentWidth.value
+        }
+      }, [ctx.slots.logo && createVNode("div", {
+        "class": "k-crud-sider__logo"
+      }, [ctx.slots.logo()]), createVNode("div", {
+        "class": "k-crud-sider__body"
+      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]), createVNode("div", {
+        "class": "k-crud-sider__trigger"
+      }, [ctx.slots.trigger ? ctx.slots.trigger({
+        collapsed: isCollapsed.value,
+        toggle
+      }) : defaultTrigger()])]);
+    };
+  }
+});
+const KHeader = /* @__PURE__ */ defineComponent({
+  name: "KHeader",
+  setup(_, ctx) {
+    return () => {
+      var _a, _b;
+      return createVNode("header", {
+        "class": "k-crud-header"
+      }, [createVNode("div", {
+        "class": "k-crud-header__main"
+      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]), ctx.slots.extra && createVNode("div", {
+        "class": "k-crud-header__extra"
+      }, [ctx.slots.extra()])]);
+    };
+  }
+});
+const KContent = /* @__PURE__ */ defineComponent({
+  name: "KContent",
+  setup(_, ctx) {
+    return () => {
+      var _a, _b;
+      return createVNode("main", {
+        "class": "k-crud-content"
+      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]);
+    };
+  }
+});
+const props$1 = {
+  data: { type: Array, default: () => [] },
+  height: { type: String, default: null },
+  paramClass: { type: Boolean, default: false },
+  loading: { type: Boolean, default: false }
+};
+function useTable() {
+  const error = (msg) => console.warn(`[水墨UI表格组件] ${msg}`);
+  const initTable = (renders, columns, data) => {
+    const tbodyTrList = [];
+    data.forEach(() => {
+      tbodyTrList.push([]);
+    });
+    const getData = (i, param) => {
+      if (data[i] && data[i][param]) {
+        return data[i][param];
+      }
+      return "";
+    };
+    const pushTd = (param, bodySlot, style) => {
+      if (param) {
+        tbodyTrList.forEach((t, i) => {
+          t.push(renders.tbodyTr({
+            data: getData(i, param),
+            style,
+            param,
+            slot: bodySlot,
+            slotInfo: {
+              data: data[i],
+              index: i
+            }
+          }));
+        });
+      } else {
+        error("param is undefined, column without param will be ignored!");
+      }
+    };
+    const getStyle = (options) => {
+      if (!options || !options.width) {
+        return {};
+      }
+      const numberWidth = Number(options.width);
+      if (!isNaN(numberWidth)) {
+        return { width: numberWidth + "px" };
+      }
+      return { width: options.width };
+    };
+    const initTHead = () => {
+      const ths = (columns ?? []).filter((column) => {
+        if (!column.props) {
+          error("column.props is undefined, column without param will be ignored!");
+          return false;
+        }
+        return true;
+      }).map((column) => {
+        const slots = renders.initSlot(column);
+        let bodySlot;
+        let headSlot;
+        const style = getStyle(column.props);
+        if (slots) {
+          bodySlot = slots.body;
+          headSlot = slots.head;
+        }
+        pushTd(column.props.param, bodySlot, style);
+        return renders.theadTh({
+          label: column.props.label,
+          param: column.props.param,
+          slot: headSlot,
+          style
+        });
+      });
+      return renders.thead(ths);
+    };
+    const thead = initTHead();
+    const tbody = tbodyTrList.length > 0 ? renders.tbody(tbodyTrList.map((tds, i) => renders.tbodyTrs(tds, i))) : renders.empty;
+    return {
+      thead,
+      tbody
+    };
+  };
+  return {
+    initTable,
+    error
+  };
+}
+const TableCore = {
+  props: props$1
+};
+const {
+  props
+} = TableCore;
+const KTable = /* @__PURE__ */ defineComponent((_props, {
+  slots
+}) => {
+  const p = _props;
+  const {
+    initTable
+  } = useTable();
+  return () => {
+    var _a, _b;
+    const columns = [];
+    const defaultSlot = ((_a = slots.default) == null ? void 0 : _a.call(slots)) ?? [];
+    defaultSlot.forEach((s) => {
+      var _a2;
+      if (s.type === Fragment) {
+        (_a2 = s.children) == null ? void 0 : _a2.forEach((c) => columns.push(c));
+        return;
+      }
+      if (s.type === Comment) return;
+      if (typeof s.type === "object" && s.type.name === "KTableColumn") {
+        columns.push(s);
+      }
+    });
+    const style = p.height ? {
+      height: p.height
+    } : void 0;
+    const {
+      thead,
+      tbody
+    } = initTable({
+      // 数据为空时的占位渲染
+      empty: createVNode("tbody", {
+        "class": "m-table-empty k-table-empty"
+      }, [createVNode("tr", null, [createVNode("th", {
+        "colspan": columns.length
+      }, [((_b = slots.empty) == null ? void 0 : _b.call(slots)) ?? "暂无数据"])])]),
+      // 渲染单个数据单元格
+      tbodyTr: ({
+        data,
+        param,
+        slot,
+        style: cellStyle,
+        slotInfo
+      }) => createVNode("td", {
+        "style": cellStyle,
+        "class": ["m-td", "k-td", p.paramClass ? `m-td-${param}` : null, p.paramClass ? `k-td-${param}` : null]
+      }, [slot ? slot({
+        data: slotInfo == null ? void 0 : slotInfo.data,
+        index: slotInfo == null ? void 0 : slotInfo.index
+      }) : data]),
+      // 渲染单个表头单元格
+      theadTh: ({
+        label,
+        param,
+        slot,
+        style: cellStyle
+      }) => createVNode("th", {
+        "class": ["m-th", "k-th", p.paramClass ? `m-th-${param}` : null, p.paramClass ? `k-th-${param}` : null],
+        "style": cellStyle
+      }, [slot ? slot() : label]),
+      // 渲染整个 thead
+      thead: (ths) => createVNode("thead", {
+        "class": "m-thead k-thead"
+      }, [createVNode("tr", {
+        "class": "m-tr k-tr"
+      }, [ths])]),
+      // 渲染整个 tbody
+      tbody: (trs) => createVNode("tbody", {
+        "class": "m-tbody k-tbody"
+      }, [trs]),
+      // 渲染单行 tr
+      tbodyTrs: (tds, i) => createVNode("tr", {
+        "class": "m-tr k-tr",
+        "key": i
+      }, [...tds]),
+      // 从 KTableColumn VNode 中提取 body / head 插槽
+      initSlot: (tableColumn) => {
+        const children = tableColumn.children;
+        if (!children || Array.isArray(children) || typeof children !== "object") {
+          return void 0;
+        }
+        return {
+          body: children.default,
+          head: children.head
+        };
+      }
+    }, columns, p.data);
+    return createVNode("div", {
+      "class": ["m-table", "k-table", p.loading && "k-table-loading-wrap"],
+      "style": style
+    }, [p.loading && createVNode("div", {
+      "class": "k-table-loading-overlay"
+    }, [createVNode("div", {
+      "class": "k-table-loading-spinner"
+    }, null)]), createVNode("table", {
+      "class": "m-table-inner k-table-inner"
+    }, [thead, tbody])]);
+  };
+}, {
+  name: "KTable",
+  props
+});
+const {
+  props: paginationProps
+} = PaginationCore;
+const KPagination = /* @__PURE__ */ defineComponent((_props, {
+  emit
+}) => {
+  const p = _props;
+  const currentValue = ref(p.modelValue ?? p.defaultCurrent ?? 1);
+  watch(() => p.modelValue, (val) => {
+    if (val !== void 0) {
+      currentValue.value = val;
+    }
+  });
+  const {
+    getPageNumList,
+    getPageBtnLength
+  } = usePagination(p, currentValue);
+  const changePage = (page) => {
+    const total = getPageBtnLength();
+    if (page < 1 || page > total) return;
+    currentValue.value = page;
+    emit("update:modelValue", page);
+    emit("change", page);
+  };
+  const toPrev = () => {
+    if (currentValue.value === 1) return;
+    changePage(currentValue.value - 1);
+  };
+  const toNext = () => {
+    if (currentValue.value === getPageBtnLength()) return;
+    changePage(currentValue.value + 1);
+  };
+  return () => {
+    const pages = getPageNumList();
+    const layoutKeys = p.layout.split(",").map((k) => k.trim());
+    const totalPages = getPageBtnLength();
+    const btnGetter = {
+      /** 总条数区域 */
+      total: () => createVNode("div", {
+        "class": "m-page-total k-page-total"
+      }, [createTextVNode("共 "), createVNode("span", null, [p.total]), createTextVNode(" 条")]),
+      /** 上一页按钮 */
+      prev: () => createVNode("div", {
+        "class": ["m-page-prev", "k-page-prev", currentValue.value === 1 ? "m-page-prev-disabled k-page-prev-disabled" : ""],
+        "onClick": toPrev
+      }, [createTextVNode("‹")]),
+      /** 页码列表（含折叠省略号） */
+      pager: () => pages.map((page) => createVNode("div", {
+        "key": `${page.type}-${page.value}`,
+        "class": ["m-pager", "k-pager", page.type === "folded" ? "m-pager-folded k-pager-folded" : "", page.isCurrent ? "m-pager-current k-pager-current" : ""],
+        "onClick": () => changePage(page.jump)
+      }, [page.value])),
+      /** 下一页按钮 */
+      next: () => createVNode("div", {
+        "class": ["m-page-next", "k-page-next", currentValue.value === totalPages ? "m-page-next-disabled k-page-next-disabled" : ""],
+        "onClick": toNext
+      }, [createTextVNode("›")])
+    };
+    return createVNode("div", {
+      "class": "m-pagination k-pagination"
+    }, [layoutKeys.map((key) => {
+      var _a;
+      return (_a = btnGetter[key]) == null ? void 0 : _a.call(btnGetter);
+    })]);
+  };
+}, {
+  name: "KPagination",
+  props: paginationProps,
+  emits: ["update:modelValue", "change"]
+});
+const KSearchTable = /* @__PURE__ */ defineComponent({
+  name: "KSearchTable",
+  props: {
+    /** 加载状态 */
+    loading: {
+      type: Boolean,
+      default: false
+    },
+    /** 表格数据 */
+    data: {
+      type: Array,
+      default: () => []
+    },
+    /** 总条数 */
+    total: {
+      type: Number,
+      default: 0
+    },
+    /** 当前页（受控，配合 v-model:page） */
+    page: {
+      type: Number,
+      default: 1
+    },
+    /** 每页条数（受控，配合 v-model:pageSize） */
+    pageSize: {
+      type: Number,
+      default: 20
+    },
+    /** 是否显示搜索区 */
+    searchable: {
+      type: Boolean,
+      default: true
+    },
+    /** 是否显示分页 */
+    pageable: {
+      type: Boolean,
+      default: true
+    },
+    /** 透传给 KTable 的额外 props */
+    tableProps: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: [
+    "update:page",
+    "update:pageSize",
+    /** 点击搜索按钮 */
+    "search",
+    /** 点击重置按钮 */
+    "reset"
+  ],
+  setup(props2, ctx) {
+    const onSearch = () => {
+      ctx.emit("search");
+    };
+    const onReset = () => {
+      ctx.emit("reset");
+    };
+    const onPageChange = (page) => {
+      ctx.emit("update:page", page);
+    };
+    return () => {
+      var _a, _b;
+      return createVNode("div", {
+        "class": ["k-search-table", props2.loading ? "k-search-table--loading" : ""]
+      }, [props2.searchable && createVNode("div", {
+        "class": "k-search-table-search"
+      }, [createVNode("div", {
+        "class": "k-search-table-search-form"
+      }, [(_b = (_a = ctx.slots).search) == null ? void 0 : _b.call(_a)]), createVNode("div", {
+        "class": "k-search-table-search-actions"
+      }, [createVNode("button", {
+        "type": "button",
+        "class": "k-search-table-btn k-search-table-btn--primary",
+        "onClick": onSearch
+      }, [createTextVNode("搜索")]), createVNode("button", {
+        "type": "button",
+        "class": "k-search-table-btn",
+        "onClick": onReset
+      }, [createTextVNode("重置")])])]), ctx.slots.toolbar && createVNode("div", {
+        "class": "k-search-table-toolbar"
+      }, [ctx.slots.toolbar()]), createVNode("div", {
+        "class": "k-search-table-body"
+      }, [createVNode(KTable, mergeProps({
+        "data": props2.data
+      }, props2.tableProps), {
+        default: ctx.slots.default,
+        empty: ctx.slots.empty
+      })]), props2.pageable && createVNode("div", {
+        "class": "k-search-table-pagination"
+      }, [createVNode(KPagination, {
+        "modelValue": props2.page,
+        "total": props2.total,
+        "pageSize": props2.pageSize,
+        "onUpdate:modelValue": onPageChange
+      }, null)])]);
+    };
+  }
+});
+const KLoginPage = /* @__PURE__ */ defineComponent({
+  name: "KLoginPage",
+  props: {
+    /** 系统名称 */
+    title: {
+      type: String,
+      default: "系统登录"
+    },
+    /** 登录中状态 */
+    loading: {
+      type: Boolean,
+      default: false
+    },
+    /** 登录提交回调 */
+    onSubmit: {
+      type: Function,
+      default: void 0
+    }
+  },
+  setup(props2, ctx) {
+    const username = ref("");
+    const password = ref("");
+    const remember = ref(false);
+    const handleSubmit = async (e) => {
+      var _a;
+      e.preventDefault();
+      if (props2.loading) return;
+      await ((_a = props2.onSubmit) == null ? void 0 : _a.call(props2, {
+        username: username.value,
+        password: password.value,
+        remember: remember.value
+      }));
+    };
+    return () => createVNode("div", {
+      "class": "k-login-page"
+    }, [createVNode("div", {
+      "class": "k-login-card"
+    }, [ctx.slots.logo && createVNode("div", {
+      "class": "k-login-logo"
+    }, [ctx.slots.logo()]), createVNode("h2", {
+      "class": "k-login-title"
+    }, [props2.title]), createVNode("form", {
+      "class": "k-login-form",
+      "onSubmit": handleSubmit
+    }, [createVNode("div", {
+      "class": "k-login-form-item"
+    }, [createVNode("label", null, [createTextVNode("用户名")]), createVNode("input", {
+      "type": "text",
+      "value": username.value,
+      "placeholder": "请输入用户名",
+      "autocomplete": "username",
+      "required": true,
+      "onInput": (e) => {
+        username.value = e.target.value;
+      }
+    }, null)]), createVNode("div", {
+      "class": "k-login-form-item"
+    }, [createVNode("label", null, [createTextVNode("密码")]), createVNode("input", {
+      "type": "password",
+      "value": password.value,
+      "placeholder": "请输入密码",
+      "autocomplete": "current-password",
+      "required": true,
+      "onInput": (e) => {
+        password.value = e.target.value;
+      }
+    }, null)]), createVNode("label", {
+      "class": "k-login-remember"
+    }, [createVNode("input", {
+      "type": "checkbox",
+      "checked": remember.value,
+      "onChange": (e) => {
+        remember.value = e.target.checked;
+      }
+    }, null), createTextVNode("记住我")]), createVNode("button", {
+      "type": "submit",
+      "class": ["k-login-submit", props2.loading && "k-login-submit--loading"],
+      "disabled": props2.loading
+    }, [props2.loading ? "登录中..." : "登 录"])]), ctx.slots.extra && createVNode("div", {
+      "class": "k-login-extra"
+    }, [ctx.slots.extra()])]), ctx.slots.footer && createVNode("div", {
+      "class": "k-login-footer"
+    }, [ctx.slots.footer()])]);
+  }
+});
+const KPageHeader = /* @__PURE__ */ defineComponent({
+  name: "KPageHeader",
+  props: {
+    /** 页面标题 */
+    title: {
+      type: String,
+      default: ""
+    },
+    /** 副标题 */
+    subtitle: {
+      type: String,
+      default: ""
+    },
+    /** 是否显示返回按钮 */
+    backable: {
+      type: Boolean,
+      default: false
+    },
+    /** 返回回调 */
+    onBack: {
+      type: Function,
+      default: void 0
+    }
+  },
+  setup(props2, ctx) {
+    const handleBack = () => {
+      var _a;
+      (_a = props2.onBack) == null ? void 0 : _a.call(props2);
+    };
+    return () => createVNode("div", {
+      "class": "k-page-header"
+    }, [ctx.slots.breadcrumb && createVNode("div", {
+      "class": "k-page-header-breadcrumb"
+    }, [ctx.slots.breadcrumb()]), createVNode("div", {
+      "class": "k-page-header-main"
+    }, [createVNode("div", {
+      "class": "k-page-header-left"
+    }, [props2.backable && createVNode("button", {
+      "type": "button",
+      "class": "k-page-header-back",
+      "aria-label": "返回",
+      "onClick": handleBack
+    }, [createTextVNode("←")]), createVNode("div", {
+      "class": "k-page-header-heading"
+    }, [props2.title && createVNode("h2", {
+      "class": "k-page-header-title"
+    }, [props2.title]), props2.subtitle && createVNode("p", {
+      "class": "k-page-header-subtitle"
+    }, [props2.subtitle])])]), ctx.slots.extra && createVNode("div", {
+      "class": "k-page-header-extra"
+    }, [ctx.slots.extra()])]), ctx.slots.default && createVNode("div", {
+      "class": "k-page-header-content"
+    }, [ctx.slots.default()])]);
+  }
+});
+function normalizeRef(value) {
+  return isRef(value) ? value : toRef(() => value);
+}
+function defineRepository(domain, endpoints) {
+  const useList = (params) => {
+    const paramsRef = normalizeRef(params ?? {});
+    const query = useQuery({
+      // query key 包含 params，params 变化时自动重新请求
+      queryKey: computed(() => [domain, "list", paramsRef.value]),
+      queryFn: () => {
+        if (!endpoints.list) {
+          return Promise.reject(new Error(`[defineRepository:${domain}] list endpoint 未定义`));
+        }
+        return endpoints.list(paramsRef.value);
+      }
+    });
+    return {
+      data: computed(() => query.data.value),
+      isLoading: computed(() => query.isLoading.value),
+      isFetching: computed(() => query.isFetching.value),
+      isError: computed(() => query.isError.value),
+      error: computed(() => query.error.value),
+      refetch: () => {
+        query.refetch();
+      }
+    };
+  };
+  const useDetail = (id) => {
+    const idRef = normalizeRef(id);
+    const query = useQuery({
+      queryKey: computed(() => [domain, "detail", idRef.value]),
+      queryFn: () => {
+        if (!endpoints.detail) {
+          return Promise.reject(new Error(`[defineRepository:${domain}] detail endpoint 未定义`));
+        }
+        return endpoints.detail(idRef.value);
+      },
+      // id 为空时不发请求
+      enabled: computed(() => idRef.value !== void 0 && idRef.value !== null && idRef.value !== "")
+    });
+    return {
+      data: computed(() => query.data.value),
+      isLoading: computed(() => query.isLoading.value),
+      isFetching: computed(() => query.isFetching.value),
+      isError: computed(() => query.isError.value),
+      error: computed(() => query.error.value),
+      refetch: () => {
+        query.refetch();
+      }
+    };
+  };
+  function buildInvalidateHandler(options) {
+    return async (queryClient) => {
+      var _a;
+      await queryClient.invalidateQueries({ queryKey: [domain] });
+      if ((_a = options == null ? void 0 : options.invalidates) == null ? void 0 : _a.length) {
+        await Promise.all(
+          options.invalidates.map(
+            (d) => queryClient.invalidateQueries({ queryKey: [d] })
+          )
+        );
+      }
+    };
+  }
+  const useCreate = (options) => {
+    const queryClient = useQueryClient();
+    const invalidate = buildInvalidateHandler(options);
+    const mutation = useMutation({
+      mutationFn: (data) => {
+        if (!endpoints.create) {
+          return Promise.reject(new Error(`[defineRepository:${domain}] create endpoint 未定义`));
+        }
+        return endpoints.create(data);
+      },
+      onSuccess: () => invalidate(queryClient)
+    });
+    return {
+      // 类型断言：确保签名与泛型约束一致
+      mutate: (data) => mutation.mutateAsync(data),
+      isPending: computed(() => mutation.isPending.value),
+      isError: computed(() => mutation.isError.value),
+      error: computed(() => mutation.error.value)
+    };
+  };
+  const useUpdate = (options) => {
+    const queryClient = useQueryClient();
+    const invalidate = buildInvalidateHandler(options);
+    const mutation = useMutation({
+      mutationFn: ({ id, data }) => {
+        if (!endpoints.update) {
+          return Promise.reject(new Error(`[defineRepository:${domain}] update endpoint 未定义`));
+        }
+        return endpoints.update(id, data);
+      },
+      onSuccess: () => invalidate(queryClient)
+    });
+    return {
+      mutate: (variables) => mutation.mutateAsync(variables),
+      isPending: computed(() => mutation.isPending.value),
+      isError: computed(() => mutation.isError.value),
+      error: computed(() => mutation.error.value)
+    };
+  };
+  const useRemove = (options) => {
+    const queryClient = useQueryClient();
+    const invalidate = buildInvalidateHandler(options);
+    const mutation = useMutation({
+      mutationFn: (id) => {
+        if (!endpoints.remove) {
+          return Promise.reject(new Error(`[defineRepository:${domain}] remove endpoint 未定义`));
+        }
+        return endpoints.remove(id);
+      },
+      onSuccess: () => invalidate(queryClient)
+    });
+    return {
+      mutate: (id) => mutation.mutateAsync(id),
+      isPending: computed(() => mutation.isPending.value),
+      isError: computed(() => mutation.isError.value),
+      error: computed(() => mutation.error.value)
+    };
+  };
+  return { useList, useDetail, useCreate, useUpdate, useRemove };
+}
+function createStorageAdapter(storageType) {
+  function resolveStorage() {
+    if (typeof window === "undefined") return null;
+    return storageType === "local" ? window.localStorage : window.sessionStorage;
+  }
+  return {
+    get(key) {
+      const storage = resolveStorage();
+      if (!storage) return null;
+      const raw = storage.getItem(key);
+      if (raw === null) return null;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    },
+    set(key, value) {
+      const storage = resolveStorage();
+      if (!storage) return;
+      storage.setItem(key, typeof value === "string" ? value : JSON.stringify(value));
+    },
+    remove(key) {
+      const storage = resolveStorage();
+      if (!storage) return;
+      storage.removeItem(key);
+    }
+  };
+}
+const AUTH_INJECT_KEY = Symbol("kine-design:auth");
+const SCOPE_LEVEL = {
+  own: 1,
+  department: 2,
+  all: 3,
+  "*": Infinity
+};
+function isScopeSatisfied(permScope, requiredScope) {
+  const permLevel = SCOPE_LEVEL[permScope ?? "all"] ?? 0;
+  const requiredLevel = SCOPE_LEVEL[requiredScope] ?? 0;
+  return permLevel >= requiredLevel;
+}
+function matchesPermission(perm, resource, action, scope) {
+  if (perm.resource !== resource) return false;
+  const actionMatched = perm.action === "*" || perm.action === action;
+  if (!actionMatched) return false;
+  if (scope === void 0) return true;
+  return isScopeSatisfied(perm.scope, scope);
+}
+const STORAGE_KEY_TOKEN = "kine_auth_token";
+const STORAGE_KEY_USER = "kine_auth_user";
+function buildAuthReturn(state, options, adapter) {
+  const user = computed(() => state.user);
+  const permissions = computed(() => state.permissions);
+  const token = computed(() => state.token);
+  const isAuthenticated = computed(() => state.user !== null && state.token !== null);
+  function can(resource, action, scope) {
+    if (!state.permissions) return false;
+    return state.permissions.some((p) => matchesPermission(p, resource, action, scope));
+  }
+  function persistToStorage() {
+    if (!adapter) return;
+    adapter.set(STORAGE_KEY_TOKEN, state.token);
+    adapter.set(STORAGE_KEY_USER, state.user);
+  }
+  function clearStorage() {
+    if (!adapter) return;
+    adapter.remove(STORAGE_KEY_TOKEN);
+    adapter.remove(STORAGE_KEY_USER);
+  }
+  async function login() {
+    const result = await options.fetchUser();
+    state.user = result.user;
+    state.permissions = result.permissions;
+    state.token = result.token;
+    persistToStorage();
+  }
+  function loginWith(result) {
+    state.user = result.user;
+    state.permissions = result.permissions;
+    state.token = result.token;
+    persistToStorage();
+  }
+  function logout() {
+    state.user = null;
+    state.permissions = [];
+    state.token = null;
+    clearStorage();
+  }
+  async function restore() {
+    if (!adapter) return;
+    const storedToken = adapter.get(STORAGE_KEY_TOKEN);
+    const storedUser = adapter.get(STORAGE_KEY_USER);
+    if (!storedToken || !storedUser) return;
+    state.token = storedToken;
+    state.user = storedUser;
+    try {
+      const result = await options.fetchUser();
+      state.user = result.user;
+      state.permissions = result.permissions;
+      state.token = result.token;
+      persistToStorage();
+    } catch {
+      state.user = null;
+      state.permissions = [];
+      state.token = null;
+      clearStorage();
+    }
+  }
+  return { user, permissions, token, isAuthenticated, can, login, loginWith, logout, restore };
+}
+function createAuth(app, options) {
+  const state = reactive({
+    user: null,
+    permissions: [],
+    token: null
+  });
+  const storageType = options.storage ?? false;
+  const adapter = storageType !== false ? createStorageAdapter(storageType) : null;
+  const auth = buildAuthReturn(state, options, adapter);
+  if (storageType === "local" && typeof window !== "undefined") {
+    const onStorageChange = (e) => {
+      if (e.key !== STORAGE_KEY_TOKEN) return;
+      if (e.newValue === null) {
+        state.user = null;
+        state.permissions = [];
+        state.token = null;
+      }
+    };
+    window.addEventListener("storage", onStorageChange);
+  }
+  app.provide(AUTH_INJECT_KEY, { auth, onUnauthorized: options.onUnauthorized });
+  return auth;
+}
+function useAuth() {
+  const provided = inject(AUTH_INJECT_KEY);
+  if (!provided) {
+    throw new Error("[useAuth] 未找到 auth 实例，请先在根 App 调用 createAuth()。");
+  }
+  return provided.auth;
+}
+function createAuthGuard(auth, options) {
+  const loginPath = (options == null ? void 0 : options.loginPath) ?? "/login";
+  const forbiddenPath = (options == null ? void 0 : options.forbiddenPath) ?? "/403";
+  return (to) => {
+    const meta = to.meta;
+    const requiresAuth = meta.requiresAuth !== false;
+    if (requiresAuth && !auth.isAuthenticated.value) {
+      if (loginPath === false) return void 0;
+      if (to.path === loginPath) return void 0;
+      return loginPath;
+    }
+    if (meta.can) {
+      const { resource, action } = meta.can;
+      if (!auth.can(resource, action)) {
+        if (forbiddenPath === false) return void 0;
+        if (to.path === forbiddenPath) return void 0;
+        return forbiddenPath;
+      }
+    }
+    return void 0;
+  };
+}
+function parseBinding(value) {
+  if (typeof value === "object") return value;
+  const parts = value.split(":");
+  const resource = parts[0] ?? "";
+  const action = parts[1] ?? "";
+  const scope = parts[2];
+  return { resource, action, scope };
+}
+function applyVisibility(el, auth, binding) {
+  const { resource, action, scope } = parseBinding(binding);
+  const allowed = auth.can(resource, action, scope);
+  el.style.display = allowed ? "" : "none";
+}
+function createVCan(auth) {
+  return {
+    mounted(el, binding) {
+      applyVisibility(el, auth, binding.value);
+    },
+    updated(el, binding) {
+      applyVisibility(el, auth, binding.value);
+    }
+  };
+}
+function buildCacheKey(method, url, body) {
+  const bodyStr = body !== void 0 && body !== null ? stableStringify(body) : "";
+  return `${method}:${url}:${bodyStr}`;
+}
+function stableStringify(obj) {
+  if (obj === null || obj === void 0) return "";
+  if (typeof obj !== "object") return String(obj);
+  if (obj instanceof FormData || obj instanceof Blob || obj instanceof File) return "";
+  if (Array.isArray(obj)) return `[${obj.map(stableStringify).join(",")}]`;
+  const sorted = Object.keys(obj).sort();
+  const pairs = sorted.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${pairs.join(",")}}`;
+}
+class ControlGate {
+  constructor() {
+    /** 防抖：取消前一个 timer */
+    __publicField(this, "debounceMap", /* @__PURE__ */ new Map());
+    /** 节流：记录上次执行时间 */
+    __publicField(this, "throttleMap", /* @__PURE__ */ new Map());
+    /** 去重：共享同一个 Promise */
+    __publicField(this, "deduplicateMap", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 通过控制门执行请求。
+   * 按配置依次应用防抖、节流、去重策略。
+   */
+  async execute(key, fn, policy) {
+    if (policy.debounce !== void 0 && policy.debounce > 0) {
+      return this.withDebounce(key, fn, policy.debounce);
+    }
+    if (policy.throttle !== void 0 && policy.throttle > 0) {
+      await this.waitThrottle(key, policy.throttle);
+    }
+    if (policy.deduplicate) {
+      return this.withDeduplicate(key, fn);
+    }
+    return fn();
+  }
+  /** 清理所有挂起的 timer 和状态 */
+  dispose() {
+    for (const entry of this.debounceMap.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("ControlGate 已销毁"));
+    }
+    this.debounceMap.clear();
+    this.throttleMap.clear();
+    this.deduplicateMap.clear();
+  }
+  // ── 防抖 ──────────────────────────────────────────────────────────────────
+  withDebounce(key, fn, delay) {
+    const prev = this.debounceMap.get(key);
+    if (prev) {
+      clearTimeout(prev.timer);
+      prev.reject(new Error("请求已被防抖取消"));
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(async () => {
+        this.debounceMap.delete(key);
+        try {
+          resolve(await fn());
+        } catch (e) {
+          reject(e);
+        }
+      }, delay);
+      this.debounceMap.set(key, { timer, reject });
+    });
+  }
+  // ── 节流 ──────────────────────────────────────────────────────────────────
+  waitThrottle(key, interval) {
+    const lastTime = this.throttleMap.get(key) ?? 0;
+    const now = Date.now();
+    const elapsed = now - lastTime;
+    if (elapsed >= interval) {
+      this.throttleMap.set(key, now);
+      return Promise.resolve();
+    }
+    const waitTime = interval - elapsed;
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        this.throttleMap.set(key, Date.now());
+        resolve();
+      }, waitTime);
+    });
+  }
+  // ── 去重 ──────────────────────────────────────────────────────────────────
+  withDeduplicate(key, fn) {
+    const existing = this.deduplicateMap.get(key);
+    if (existing) return existing;
+    const promise = fn().finally(() => {
+      this.deduplicateMap.delete(key);
+    });
+    this.deduplicateMap.set(key, promise);
+    return promise;
+  }
+}
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key.toLowerCase()] = value;
+  });
+  return record;
+}
+function wrapFetchResponse(response) {
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: headersToRecord(response.headers),
+    body: response.body,
+    text: () => response.text(),
+    json: () => response.json(),
+    blob: () => response.blob()
+  };
+}
+class FetchTransport {
+  async send(request) {
+    const controller = new AbortController();
+    if (request.signal) {
+      if (request.signal.aborted) {
+        controller.abort(request.signal.reason);
+      } else {
+        request.signal.addEventListener("abort", () => {
+          controller.abort(request.signal.reason);
+        }, { once: true });
+      }
+    }
+    let timeoutId;
+    if (request.timeout !== void 0 && request.timeout > 0) {
+      timeoutId = setTimeout(() => controller.abort("timeout"), request.timeout);
+    }
+    try {
+      const response = await fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: controller.signal
+      });
+      return wrapFetchResponse(response);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        if (controller.signal.reason === "timeout") {
+          throw { type: "timeout" };
+        }
+        throw { type: "aborted" };
+      }
+      throw error;
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+}
+class BusinessError extends Error {
+  constructor(message) {
+    super(message);
+    __publicField(this, "name", "BusinessError");
+  }
+}
+class NetworkRequestError extends Error {
+  constructor(detail) {
+    super(networkErrorMessage(detail));
+    __publicField(this, "name", "NetworkRequestError");
+    __publicField(this, "detail");
+    this.detail = detail;
+  }
+}
+function networkErrorMessage(e) {
+  switch (e.type) {
+    case "invalidURL":
+      return `无效的 URL: ${e.url}`;
+    case "timeout":
+      return "请求超时";
+    case "httpError":
+      return `HTTP ${e.status} ${e.statusText}`;
+    case "decodingFailed":
+      return `解码失败: ${e.reason}`;
+    case "aborted":
+      return "请求已取消";
+    case "unknown":
+      return `未知错误: ${String(e.error)}`;
+  }
+}
+const cacheStore = /* @__PURE__ */ new Map();
+function containsFile(obj) {
+  if (obj instanceof File || obj instanceof Blob || obj instanceof FormData) return true;
+  if (typeof obj === "object" && obj !== null) {
+    return Object.values(obj).some(containsFile);
+  }
+  return false;
+}
+function toFormData(obj) {
+  const fd = new FormData();
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof File || value instanceof Blob) {
+      fd.append(key, value);
+    } else if (Array.isArray(value)) {
+      value.forEach((item) => {
+        if (item instanceof File || item instanceof Blob) {
+          fd.append(key, item);
+        } else {
+          fd.append(key, String(item));
+        }
+      });
+    } else if (value !== null && value !== void 0) {
+      fd.append(key, String(value));
+    }
+  }
+  return fd;
+}
+function toQueryString(params) {
+  const parts = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === void 0) continue;
+    if (Array.isArray(value)) {
+      value.forEach((v) => parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`));
+    } else {
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  return parts.join("&");
+}
+async function unwrapResponse(response) {
+  if (response.status < 200 || response.status >= 300) {
+    throw new NetworkRequestError({
+      type: "httpError",
+      status: response.status,
+      statusText: response.statusText
+    });
+  }
+  const contentType = response.headers["content-type"] ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await response.json();
+    if (isWrappedResponse$1(json)) {
+      if (!json.success) {
+        throw new BusinessError(json.message || "请求失败");
+      }
+      return json.data;
+    }
+    return json;
+  }
+  const text = await response.text();
+  return text;
+}
+function isWrappedResponse$1(value) {
+  return typeof value === "object" && value !== null && "success" in value && "data" in value && typeof value.success === "boolean";
+}
+async function withRetry(fn, policy, signal) {
+  if (policy.type === "none") return fn();
+  let lastError;
+  const maxAttempts = policy.maxAttempts;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e;
+      if (signal == null ? void 0 : signal.aborted) throw e;
+      if (e instanceof BusinessError) throw e;
+      if (attempt < maxAttempts) {
+        const delay = policy.type === "fixed" ? policy.delay : Math.min(policy.initialDelay * Math.pow(policy.multiplier, attempt - 1), policy.maxDelay);
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(resolve, delay);
+          signal == null ? void 0 : signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(new NetworkRequestError({ type: "aborted" }));
+          }, { once: true });
+        });
+      }
+    }
+  }
+  throw lastError;
+}
+class RequestBuilder {
+  constructor(context, method, url, body) {
+    __publicField(this, "method");
+    __publicField(this, "url");
+    __publicField(this, "body");
+    __publicField(this, "config", {});
+    __publicField(this, "context");
+    __publicField(this, "customHeaders", {});
+    this.context = context;
+    this.method = method;
+    this.url = url;
+    this.body = body;
+  }
+  // ── 链式 API ────────────────────────────────────────────────────────────
+  cache(policy) {
+    this.config.cache = policy;
+    return this;
+  }
+  retry(policy) {
+    this.config.retry = policy;
+    return this;
+  }
+  debounce(delay) {
+    this.config.control = { ...this.config.control, debounce: delay };
+    return this;
+  }
+  throttle(interval) {
+    this.config.control = { ...this.config.control, throttle: interval };
+    return this;
+  }
+  deduplicate(enabled = true) {
+    this.config.control = { ...this.config.control, deduplicate: enabled };
+    return this;
+  }
+  timeout(ms) {
+    this.config.timeout = ms;
+    return this;
+  }
+  totalTimeout(ms) {
+    this.config.totalTimeout = ms;
+    return this;
+  }
+  lifecycle(lc) {
+    this.config.lifecycle = lc;
+    return this;
+  }
+  priority(p) {
+    this.config.control = { ...this.config.control, priority: p };
+    return this;
+  }
+  headers(h2) {
+    Object.assign(this.customHeaders, h2);
+    return this;
+  }
+  // ── 执行 ────────────────────────────────────────────────────────────────
+  async execute() {
+    const { transport, controlGate, baseURL, defaultHeaders, getToken, onUnauthorized, responseInterceptor, registerAbort } = this.context;
+    let fullURL = this.url.startsWith("http") ? this.url : `${baseURL}${this.url}`;
+    const abortController = new AbortController();
+    registerAbort == null ? void 0 : registerAbort(abortController);
+    let totalTimeoutId;
+    if (this.config.totalTimeout) {
+      totalTimeoutId = setTimeout(() => abortController.abort("totalTimeout"), this.config.totalTimeout);
+    }
+    try {
+      const reqHeaders = { ...defaultHeaders, ...this.customHeaders };
+      const token = getToken == null ? void 0 : getToken();
+      if (token) {
+        reqHeaders["Authorization"] = `Bearer ${token}`;
+      }
+      let reqBody = null;
+      if (this.method === "GET" && this.body && typeof this.body === "object") {
+        const qs = toQueryString(this.body);
+        if (qs) {
+          fullURL += (fullURL.includes("?") ? "&" : "?") + qs;
+        }
+      } else if (this.body !== void 0 && this.body !== null) {
+        if (this.body instanceof FormData) {
+          reqBody = this.body;
+        } else if (containsFile(this.body)) {
+          reqBody = toFormData(this.body);
+        } else {
+          reqBody = JSON.stringify(this.body);
+          reqHeaders["Content-Type"] = "application/json";
+        }
+      }
+      const cacheKey = buildCacheKey(this.method, fullURL, this.body);
+      const cachePolicy = this.config.cache ?? { type: "none" };
+      if (cachePolicy.type === "cacheFirst" || cachePolicy.type === "staleWhileRevalidate") {
+        const cached = cacheStore.get(cacheKey);
+        if (cached) {
+          const age = (Date.now() - cached.timestamp) / 1e3;
+          if (age < cachePolicy.maxAge) {
+            if (cachePolicy.type === "staleWhileRevalidate") {
+              this.executeTransport(transport, fullURL, reqHeaders, reqBody, abortController.signal).then((data) => {
+                cacheStore.set(cacheKey, { data, timestamp: Date.now() });
+              }).catch(() => {
+              });
+            }
+            return cached.data;
+          }
+        }
+      }
+      const doRequest = () => this.executeTransport(transport, fullURL, reqHeaders, reqBody, abortController.signal);
+      const controlPolicy = this.config.control ?? {};
+      const retryPolicy = this.config.retry ?? { type: "none" };
+      const result = await controlGate.execute(cacheKey, async () => {
+        return withRetry(doRequest, retryPolicy, abortController.signal);
+      }, controlPolicy);
+      if (cachePolicy.type !== "none") {
+        cacheStore.set(cacheKey, { data: result, timestamp: Date.now() });
+      }
+      const finalResult = responseInterceptor ? responseInterceptor(result) : result;
+      return finalResult;
+    } catch (error) {
+      if (error instanceof NetworkRequestError && error.detail.type === "httpError" && error.detail.status === 401) {
+        onUnauthorized == null ? void 0 : onUnauthorized();
+      }
+      throw error;
+    } finally {
+      if (totalTimeoutId !== void 0) clearTimeout(totalTimeoutId);
+    }
+  }
+  // ── 内部传输 ──────────────────────────────────────────────────────────────
+  async executeTransport(transport, url, headers, body, signal) {
+    const response = await transport.send({
+      url,
+      method: this.method,
+      headers,
+      body,
+      signal,
+      timeout: this.config.timeout
+    });
+    return unwrapResponse(response);
+  }
+}
+function createRequest(options = {}) {
+  const transport = options.transport ?? new FetchTransport();
+  const controlGate = new ControlGate();
+  const abortControllers = /* @__PURE__ */ new Set();
+  const context = {
+    transport,
+    controlGate,
+    baseURL: options.baseURL ?? "",
+    defaultHeaders: options.headers ?? {},
+    getToken: options.getToken,
+    onUnauthorized: options.onUnauthorized,
+    responseInterceptor: options.responseInterceptor,
+    registerAbort: (controller) => {
+      abortControllers.add(controller);
+      const originalAbort = controller.abort.bind(controller);
+      controller.abort = (reason) => {
+        abortControllers.delete(controller);
+        return originalAbort(reason);
+      };
+    }
+  };
+  function createBuilder(method, url, body) {
+    var _a, _b, _c;
+    const builder = new RequestBuilder(context, method, url, body);
+    const dc = options.defaultConfig;
+    if (dc == null ? void 0 : dc.cache) builder.cache(dc.cache);
+    if (dc == null ? void 0 : dc.retry) builder.retry(dc.retry);
+    if (dc == null ? void 0 : dc.timeout) builder.timeout(dc.timeout);
+    if (dc == null ? void 0 : dc.totalTimeout) builder.totalTimeout(dc.totalTimeout);
+    if (dc == null ? void 0 : dc.lifecycle) builder.lifecycle(dc.lifecycle);
+    if ((_a = dc == null ? void 0 : dc.control) == null ? void 0 : _a.debounce) builder.debounce(dc.control.debounce);
+    if ((_b = dc == null ? void 0 : dc.control) == null ? void 0 : _b.throttle) builder.throttle(dc.control.throttle);
+    if ((_c = dc == null ? void 0 : dc.control) == null ? void 0 : _c.deduplicate) builder.deduplicate(dc.control.deduplicate);
+    return builder;
+  }
+  const client = {
+    send: (method, url, body) => createBuilder(method, url, body).execute(),
+    get: (url, params) => createBuilder("GET", url, params).execute(),
+    post: (url, body) => createBuilder("POST", url, body).execute(),
+    put: (url, body) => createBuilder("PUT", url, body).execute(),
+    patch: (url, body) => createBuilder("PATCH", url, body).execute(),
+    delete: (url, body) => createBuilder("DELETE", url, body).execute(),
+    request: (method, url, body) => createBuilder(method, url, body),
+    registerAbortController: (controller) => {
+      abortControllers.add(controller);
+    },
+    abortAll: () => {
+      for (const controller of abortControllers) {
+        controller.abort("客户端取消所有请求");
+      }
+      abortControllers.clear();
+    },
+    dispose: () => {
+      client.abortAll();
+      controlGate.dispose();
+    }
+  };
+  return client;
+}
+function createDefaultRequest(options = {}) {
+  return createRequest({
+    ...options,
+    defaultConfig: {
+      retry: { type: "exponential", maxAttempts: 3, initialDelay: 300, multiplier: 2, maxDelay: 5e3 },
+      timeout: 3e4,
+      ...options.defaultConfig
+    }
+  });
+}
+function createStrictRequest(options = {}) {
+  return createRequest({
+    ...options,
+    defaultConfig: {
+      retry: { type: "none" },
+      timeout: 1e4,
+      ...options.defaultConfig
+    }
+  });
+}
+function createPermissiveRequest(options = {}) {
+  return createRequest({
+    ...options,
+    defaultConfig: {
+      retry: { type: "exponential", maxAttempts: 5, initialDelay: 500, multiplier: 2, maxDelay: 3e4 },
+      timeout: 6e4,
+      totalTimeout: 12e4,
+      ...options.defaultConfig
+    }
+  });
+}
+const ERROR_HANDLER_INJECT_KEY = Symbol("kine-design:error-handler");
+function tryGetMessageApi() {
+  try {
+    const { useMessage } = require("@kine-design/ui");
+    return useMessage();
+  } catch {
+    return null;
+  }
+}
+let messageApi = void 0;
+function getMessageApi() {
+  if (messageApi === void 0) {
+    messageApi = tryGetMessageApi();
+  }
+  return messageApi;
+}
+const defaultFeedbackHandler = {
+  showSuccess(message) {
+    const api = getMessageApi();
+    if (api) {
+      api.success(message);
+    } else {
+      console.log(`[success] ${message}`);
+    }
+  },
+  showError(message) {
+    const api = getMessageApi();
+    if (api) {
+      api.error(message);
+    } else {
+      console.error(`[error] ${message}`);
+    }
+  },
+  showWarning(message) {
+    const api = getMessageApi();
+    if (api) {
+      api.warning(message);
+    } else {
+      console.warn(`[warning] ${message}`);
+    }
+  },
+  handleAuthenticationFailure() {
+    console.warn("[auth] 认证失败，请重新登录");
+  }
+};
+function dispatchError(error, options) {
+  var _a, _b;
+  const feedback = options.feedbackHandler ?? defaultFeedbackHandler;
+  if (error instanceof BusinessError) {
+    (_a = options.onBusinessError) == null ? void 0 : _a.call(options, error);
+    feedback.showError(error.message);
+    return;
+  }
+  if (error instanceof NetworkRequestError) {
+    const detail = error.detail;
+    (_b = options.onNetworkError) == null ? void 0 : _b.call(options, detail);
+    switch (detail.type) {
+      case "httpError":
+        if (detail.status === 401) {
+          feedback.handleAuthenticationFailure();
+          return;
+        }
+        if (detail.status === 403) {
+          feedback.showWarning("权限不足，无法执行此操作");
+          return;
+        }
+        feedback.showError(`请求失败 (${detail.status})`);
+        return;
+      case "timeout":
+        feedback.showWarning("请求超时，请稍后重试");
+        return;
+      case "aborted":
+        return;
+      case "invalidURL":
+        feedback.showError(`无效的请求地址: ${detail.url}`);
+        return;
+      case "decodingFailed":
+        feedback.showError("数据解析失败");
+        return;
+      case "unknown":
+        feedback.showError("网络异常，请检查网络连接");
+        return;
+    }
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  feedback.showError(message || "发生了未知错误");
+}
+function createErrorHandler(app, options = {}) {
+  app.config.errorHandler = (err) => {
+    dispatchError(err, options);
+  };
+  app.provide(ERROR_HANDLER_INJECT_KEY, options);
+}
+const REQUEST_CLIENT_KEY = Symbol("kine-design:request");
+function useRequestClient() {
+  const client = inject(REQUEST_CLIENT_KEY);
+  if (!client) {
+    throw new Error("[useRequestClient] 未找到 RequestClient，请在 createCrudApp 中配置 request 选项。");
+  }
+  return client;
+}
+function createQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        // 窗口重新聚焦时不自动重新请求，业务层按需覆盖
+        refetchOnWindowFocus: false,
+        // 失败后重试 1 次
+        retry: 1,
+        // 数据保鲜时间 1 分钟
+        staleTime: 1e3 * 60
+      }
+    }
+  });
+}
+function setupCrud(app, options) {
+  const queryClient = (options == null ? void 0 : options.queryClient) ?? createQueryClient();
+  app.use(VueQueryPlugin, {
+    queryClient,
+    ...options == null ? void 0 : options.vueQueryOptions
+  });
+  installPinia(app);
+}
+function installPinia(app) {
+  const provides = app._context.provides;
+  const hasPinia = Object.getOwnPropertySymbols(provides).some((sym) => {
+    const val = provides[sym];
+    return val !== null && typeof val === "object" && "_a" in val;
+  });
+  if (!hasPinia) {
+    app.use(createPinia());
+  }
+}
+function createCrudApp(rootComponent, rootPropsOrOptions, crudOptions) {
+  if (rootPropsOrOptions && isCrudAppOptions(rootPropsOrOptions)) {
+    return createCrudAppWithOptions(rootComponent, rootPropsOrOptions);
+  }
+  const app = createApp(rootComponent, rootPropsOrOptions);
+  setupCrud(app, crudOptions);
+  return app;
+}
+function isCrudAppOptions(obj) {
+  return "router" in obj || "auth" in obj || "request" in obj || "error" in obj || "query" in obj;
+}
+function createCrudAppWithOptions(rootComponent, options) {
+  var _a;
+  const app = createApp(rootComponent);
+  let auth;
+  if (options.auth) {
+    auth = createAuth(app, {
+      fetchUser: options.auth.fetchUser,
+      onUnauthorized: options.auth.onUnauthorized,
+      storage: options.auth.storage
+    });
+    app.directive("can", createVCan(auth));
+    if (options.router) {
+      const guard = createAuthGuard(auth, { loginPath: options.auth.loginPath ?? "/login" });
+      options.router.beforeEach(guard);
+    }
+  }
+  if (options.router) {
+    app.use(options.router);
+  }
+  setupCrud(app, options.query);
+  if (options.request) {
+    const requestOptions = { ...options.request };
+    if (auth && !requestOptions.getToken) {
+      requestOptions.getToken = () => auth.token.value;
+    }
+    if (auth && !requestOptions.onUnauthorized) {
+      requestOptions.onUnauthorized = (_a = options.auth) == null ? void 0 : _a.onUnauthorized;
+    }
+    const client = createRequest(requestOptions);
+    app.provide(REQUEST_CLIENT_KEY, client);
+  }
+  if (options.error) {
+    createErrorHandler(app, options.error);
+  }
+  const enhancedApp = Object.create(app);
+  enhancedApp.mount = (rootContainer) => {
+    const doMount = () => app.mount(rootContainer);
+    if (auth) {
+      auth.restore().finally(doMount);
+    } else {
+      doMount();
+    }
+    return app;
+  };
+  return enhancedApp;
+}
+const DEFAULT_CONFIG = { key: "key", label: "label", children: "children" };
+function buildNodes(data, config, nodeMap, defaultExpandAll = false, parent) {
+  return data.map((item) => {
+    const key = item[config.key];
+    const childrenKey = config.children;
+    const node = {
+      ...item,
+      expand: defaultExpandAll,
+      isActive: false,
+      checked: false,
+      indeterminate: false,
+      parent,
+      isRoot: !parent
+    };
+    nodeMap.set(key, node);
+    const rawChildren = item[childrenKey];
+    if (Array.isArray(rawChildren) && rawChildren.length > 0) {
+      node.children = buildNodes(
+        rawChildren,
+        config,
+        nodeMap,
+        defaultExpandAll,
+        node
+      );
+    }
+    return node;
+  });
+}
+function useMenu(props2, emit) {
+  const config = { ...DEFAULT_CONFIG, ...props2.config };
+  const nodeMap = /* @__PURE__ */ new Map();
+  const nodesRef = shallowRef([]);
+  const initNodes = (data = []) => {
+    var _a;
+    nodeMap.clear();
+    nodesRef.value = buildNodes(data, config, nodeMap, props2.defaultExpandAll ?? false, null);
+    if ((_a = props2.checkedKeys) == null ? void 0 : _a.length) {
+      props2.checkedKeys.forEach((key) => {
+        const node = nodeMap.get(key);
+        if (node) {
+          node.checked = true;
+        }
+      });
+    }
+    triggerRef(nodesRef);
+  };
+  initNodes(props2.data ?? []);
+  if (props2.active !== void 0) {
+    const activeNode = nodeMap.get(props2.active);
+    if (activeNode) {
+      activeNode.isActive = true;
+    }
+  }
+  const toggleExpand = (node) => {
+    node.expand = !node.expand;
+    triggerRef(nodesRef);
+  };
+  const setActive = (node) => {
+    nodeMap.forEach((n) => {
+      n.isActive = false;
+    });
+    node.isActive = true;
+    triggerRef(nodesRef);
+  };
+  const toggleChecked = (node, checked) => {
+    node.checked = checked;
+    node.indeterminate = false;
+    triggerRef(nodesRef);
+  };
+  const getCheckedKeys = () => {
+    const keys = [];
+    nodeMap.forEach((node, key) => {
+      if (node.checked && !node.indeterminate) {
+        keys.push(key);
+      }
+    });
+    return keys;
+  };
+  const getNodesByKeys = (keys) => {
+    return keys.map((key) => nodeMap.get(key)).filter((n) => n !== void 0);
+  };
+  return {
+    nodesRef,
+    nodeMap,
+    initNodes,
+    toggleExpand,
+    setActive,
+    toggleChecked,
+    getCheckedKeys,
+    getNodesByKeys,
+    config
+  };
+}
+const KMenuItem = /* @__PURE__ */ defineComponent({
+  name: "KMenuItem",
+  inheritAttrs: false,
+  props: {
+    data: {
+      type: Array,
+      default: () => []
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    checkbox: {
+      type: Boolean,
+      default: false
+    },
+    root: {
+      type: Boolean,
+      default: false
+    },
+    getNodesByKeys: {
+      type: Function,
+      required: true
+    },
+    handleExpand: {
+      type: Function,
+      required: true
+    },
+    handleCheck: {
+      type: Function,
+      required: true
+    },
+    handleItemClick: {
+      type: Function,
+      required: true
+    }
+  },
+  setup(_props, {
+    slots
+  }) {
+    const props2 = _props;
+    const clickEvent = (e, d) => {
+      props2.handleItemClick(d, e);
+    };
+    const expandEvent = (e, d) => {
+      props2.handleExpand(d, e);
+      e.stopPropagation();
+    };
+    const checkEvent = (e, d) => {
+      const checked = e.target.checked;
+      props2.handleCheck(d, checked);
+    };
+    return () => {
+      const {
+        label: l,
+        key: k,
+        children: c
+      } = props2.config;
+      const KMenuItemComp = resolveComponent("KMenuItem");
+      return createVNode(Fragment, null, [props2.data.map((d) => {
+        const childNodes = d.children ? d.children : (() => {
+          const raw = d[c];
+          return raw ? props2.getNodesByKeys(raw.map((it) => it[k])) : [];
+        })();
+        const hasChildren = childNodes.length > 0;
+        return createVNode("li", {
+          "key": d[k],
+          "class": ["m-menu-item", "k-menu-item", {
+            "m-menu-item-root": props2.root
+          }, {
+            "k-menu-item-root": props2.root
+          }, {
+            "m-menu-item-disabled": !!d.disabled
+          }, {
+            "k-menu-item-disabled": !!d.disabled
+          }, {
+            "m-menu-item-active": !!d.isActive
+          }, {
+            "k-menu-item-active": !!d.isActive
+          }],
+          "onClick": (e) => clickEvent(e, d)
+        }, [createVNode("div", {
+          "class": "m-menu-item-content k-menu-item-content"
+        }, [props2.checkbox ? createVNode("input", {
+          "type": "checkbox",
+          "class": "m-menu-item-checkbox k-menu-item-checkbox",
+          "checked": !!d.checked,
+          "disabled": !!d.disabled,
+          "onChange": (e) => checkEvent(e, d),
+          "onClick": (e) => e.stopPropagation()
+        }, null) : null, createVNode("span", {
+          "class": "m-menu-item-label k-menu-item-label",
+          "onClick": (e) => expandEvent(e, d)
+        }, [slots.default ? slots.default({
+          data: d[l],
+          node: d
+        }) : d[l]]), hasChildren ? createVNode("span", {
+          "class": ["m-menu-item-arrow", "k-menu-item-arrow", {
+            "m-menu-item-arrow-expand": d.expand
+          }, {
+            "k-menu-item-arrow-expand": d.expand
+          }],
+          "onClick": (e) => expandEvent(e, d)
+        }, null) : null]), hasChildren && d.expand ? createVNode("div", {
+          "class": "m-menu-item-children k-menu-item-children"
+        }, [h(KMenuItemComp, {
+          data: childNodes,
+          config: props2.config,
+          checkbox: props2.checkbox,
+          root: false,
+          getNodesByKeys: props2.getNodesByKeys,
+          handleExpand: props2.handleExpand,
+          handleCheck: props2.handleCheck,
+          handleItemClick: props2.handleItemClick
+        }, slots.default ? {
+          default: slots.default
+        } : void 0)]) : null]);
+      })]);
+    };
+  }
+});
+function findKeyByPath(data, path) {
+  for (const item of data) {
+    if (item.path === path) return item.key;
+    if (item.children) {
+      const found = findKeyByPath(item.children, path);
+      if (found !== null) return found;
+    }
+  }
+  return null;
+}
+const KNavMenu = /* @__PURE__ */ defineComponent({
+  name: "KNavMenu",
+  props: {
+    data: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(props2, {
+    slots
+  }) {
+    const router = useRouter();
+    const route = useRoute();
+    const {
+      nodesRef,
+      nodeMap,
+      initNodes,
+      toggleExpand,
+      setActive,
+      getNodesByKeys,
+      config
+    } = useMenu({
+      data: props2.data
+    });
+    watch(() => props2.data, (newData) => {
+      initNodes(newData ?? []);
+      syncActiveByRoute(route.path);
+    }, {
+      deep: true
+    });
+    const syncActiveByRoute = (path) => {
+      const key = findKeyByPath(props2.data, path);
+      if (key === null) return;
+      const node = nodeMap.get(key);
+      if (!node) return;
+      setActive(node);
+      let parent = node.parent;
+      while (parent) {
+        if (!parent.expand) {
+          parent.expand = true;
+        }
+        parent = parent.parent;
+      }
+    };
+    watch(() => route.path, syncActiveByRoute);
+    onMounted(() => {
+      syncActiveByRoute(route.path);
+    });
+    const handleItemClick = (node, e) => {
+      if (node.disabled) return;
+      const navNode = node;
+      if (navNode.path) {
+        router.push(navNode.path);
+        setActive(node);
+      } else {
+        toggleExpand(node);
+      }
+      e.stopPropagation();
+    };
+    const handleExpand = (node, e) => {
+      if (node.disabled) return;
+      const navNode = node;
+      const hasChildren = node.children && node.children.length > 0;
+      if (hasChildren) {
+        toggleExpand(node);
+      } else if (navNode.path) {
+        router.push(navNode.path);
+        setActive(node);
+      }
+      e.stopPropagation();
+    };
+    const handleCheck = () => {
+    };
+    const defaultSlot = slots.default ? slots.default : (slotProps) => {
+      const label = slotProps.data;
+      const icon = slotProps.node ? slotProps.node.icon : void 0;
+      return [icon ? h("span", {
+        class: "k-nav-menu-icon"
+      }, icon) : null, h("span", {
+        class: "k-nav-menu-label"
+      }, label)];
+    };
+    return () => createVNode("div", {
+      "class": "k-nav-menu"
+    }, [createVNode(KMenuItem, {
+      "data": [...nodesRef.value],
+      "config": config,
+      "checkbox": false,
+      "root": true,
+      "getNodesByKeys": getNodesByKeys,
+      "handleExpand": handleExpand,
+      "handleCheck": handleCheck,
+      "handleItemClick": handleItemClick
+    }, {
+      default: defaultSlot
+    })]);
+  }
+});
+let uidCounter$1 = 0;
+function genUid$1() {
+  return `upload-${Date.now()}-${++uidCounter$1}`;
+}
+function formatSize$1(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+const KUpload = /* @__PURE__ */ defineComponent({
+  name: "KUpload",
+  props: {
+    request: {
+      type: Function,
+      required: true
+    },
+    accept: {
+      type: String,
+      default: ""
+    },
+    multiple: {
+      type: Boolean,
+      default: false
+    },
+    maxCount: {
+      type: Number,
+      default: Infinity
+    },
+    maxSize: {
+      type: Number,
+      default: Infinity
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    fileList: {
+      type: Array,
+      default: () => []
+    },
+    drag: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ["update:fileList", "change", "error"],
+  setup(props2, ctx) {
+    const inputRef = ref(null);
+    const isDragOver = ref(false);
+    const openFileDialog = () => {
+      var _a;
+      if (props2.disabled) return;
+      (_a = inputRef.value) == null ? void 0 : _a.click();
+    };
+    const validateFile = (file) => {
+      if (props2.maxSize !== Infinity && file.size > props2.maxSize) {
+        return `文件 "${file.name}" 超过大小限制（最大 ${formatSize$1(props2.maxSize)}）`;
+      }
+      return null;
+    };
+    const processFiles = async (rawFiles) => {
+      const fileArray = Array.from(rawFiles);
+      const currentCount = props2.fileList.length;
+      const remaining = props2.maxCount - currentCount;
+      if (remaining <= 0) return;
+      const filesToProcess = fileArray.slice(0, remaining);
+      const newList = [...props2.fileList];
+      for (const raw of filesToProcess) {
+        const err = validateFile(raw);
+        if (err) {
+          ctx.emit("error", {
+            file: raw,
+            message: err
+          });
+          continue;
+        }
+        const uploadFile = {
+          uid: genUid$1(),
+          name: raw.name,
+          size: raw.size,
+          type: raw.type,
+          status: "pending",
+          percent: 0,
+          raw
+        };
+        newList.push(uploadFile);
+        ctx.emit("update:fileList", [...newList]);
+        ctx.emit("change", uploadFile);
+        const idx = newList.indexOf(uploadFile);
+        newList[idx] = {
+          ...uploadFile,
+          status: "uploading"
+        };
+        ctx.emit("update:fileList", [...newList]);
+        try {
+          const result = await props2.request(raw, (percent) => {
+            const current2 = newList.find((f) => f.uid === uploadFile.uid);
+            if (current2) {
+              const i = newList.indexOf(current2);
+              newList[i] = {
+                ...current2,
+                percent
+              };
+              ctx.emit("update:fileList", [...newList]);
+            }
+          });
+          const current = newList.find((f) => f.uid === uploadFile.uid);
+          if (current) {
+            const i = newList.indexOf(current);
+            newList[i] = {
+              ...current,
+              status: "success",
+              percent: 100,
+              url: result.url
+            };
+            ctx.emit("update:fileList", [...newList]);
+            ctx.emit("change", newList[i]);
+          }
+        } catch (e) {
+          const current = newList.find((f) => f.uid === uploadFile.uid);
+          if (current) {
+            const i = newList.indexOf(current);
+            newList[i] = {
+              ...current,
+              status: "error"
+            };
+            ctx.emit("update:fileList", [...newList]);
+            ctx.emit("error", {
+              file: raw,
+              message: String(e)
+            });
+          }
+        }
+      }
+    };
+    const onInputChange = (e) => {
+      const target = e.target;
+      if (target.files) {
+        processFiles(target.files);
+        target.value = "";
+      }
+    };
+    const onDragOver = (e) => {
+      if (props2.disabled || !props2.drag) return;
+      e.preventDefault();
+      isDragOver.value = true;
+    };
+    const onDragLeave = () => {
+      isDragOver.value = false;
+    };
+    const onDrop = (e) => {
+      var _a;
+      if (props2.disabled || !props2.drag) return;
+      e.preventDefault();
+      isDragOver.value = false;
+      if ((_a = e.dataTransfer) == null ? void 0 : _a.files) {
+        processFiles(e.dataTransfer.files);
+      }
+    };
+    return () => {
+      var _a, _b;
+      const classes = ["k-upload", props2.drag ? "k-upload-drag" : "", props2.disabled ? "k-upload-disabled" : "", isDragOver.value ? "k-upload-drag-over" : ""].filter(Boolean);
+      return createVNode("div", {
+        "class": classes,
+        "onClick": openFileDialog,
+        "onDragover": onDragOver,
+        "onDragleave": onDragLeave,
+        "onDrop": onDrop
+      }, [createVNode("input", {
+        "ref": inputRef,
+        "type": "file",
+        "class": "k-upload-input",
+        "accept": props2.accept,
+        "multiple": props2.multiple,
+        "onChange": onInputChange
+      }, null), ((_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)) ?? createVNode("div", {
+        "class": "k-upload-placeholder"
+      }, [createVNode("span", {
+        "class": "k-upload-icon"
+      }, [createTextVNode("↑")]), createVNode("span", {
+        "class": "k-upload-text"
+      }, [props2.drag ? "点击或拖拽文件到此处上传" : "点击上传文件"])])]);
+    };
+  }
+});
+let uidCounter = 0;
+function genUid() {
+  return `img-upload-${Date.now()}-${++uidCounter}`;
+}
+const KImageUpload = /* @__PURE__ */ defineComponent({
+  name: "KImageUpload",
+  props: {
+    request: {
+      type: Function,
+      required: true
+    },
+    accept: {
+      type: String,
+      default: "image/*"
+    },
+    multiple: {
+      type: Boolean,
+      default: true
+    },
+    maxCount: {
+      type: Number,
+      default: Infinity
+    },
+    maxSize: {
+      type: Number,
+      default: Infinity
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    fileList: {
+      type: Array,
+      default: () => []
+    },
+    drag: {
+      type: Boolean,
+      default: true
+    },
+    previewSize: {
+      type: String,
+      default: "100px"
+    }
+  },
+  emits: ["update:fileList", "change", "error"],
+  setup(props2, ctx) {
+    const inputRef = ref(null);
+    const isDragOver = ref(false);
+    const objectUrlMap = ref(/* @__PURE__ */ new Map());
+    const getPreviewUrl = (file) => {
+      if (file.thumbUrl) return file.thumbUrl;
+      if (file.url) return file.url;
+      if (file.raw) {
+        const existing = objectUrlMap.value.get(file.uid);
+        if (existing) return existing;
+        const url = URL.createObjectURL(file.raw);
+        objectUrlMap.value.set(file.uid, url);
+        return url;
+      }
+      return "";
+    };
+    onBeforeUnmount(() => {
+      objectUrlMap.value.forEach((url) => URL.revokeObjectURL(url));
+      objectUrlMap.value.clear();
+    });
+    const showAddCard = computed(() => !props2.disabled && props2.fileList.length < props2.maxCount);
+    const openFileDialog = () => {
+      var _a;
+      if (props2.disabled) return;
+      (_a = inputRef.value) == null ? void 0 : _a.click();
+    };
+    const processFiles = async (rawFiles) => {
+      const fileArray = Array.from(rawFiles);
+      const currentCount = props2.fileList.length;
+      const remaining = props2.maxCount - currentCount;
+      if (remaining <= 0) return;
+      const filesToProcess = fileArray.slice(0, remaining);
+      const newList = [...props2.fileList];
+      for (const raw of filesToProcess) {
+        if (props2.maxSize !== Infinity && raw.size > props2.maxSize) {
+          ctx.emit("error", {
+            file: raw,
+            message: `文件 "${raw.name}" 超过大小限制`
+          });
+          continue;
+        }
+        const uploadFile = {
+          uid: genUid(),
+          name: raw.name,
+          size: raw.size,
+          type: raw.type,
+          status: "uploading",
+          percent: 0,
+          raw
+        };
+        newList.push(uploadFile);
+        ctx.emit("update:fileList", [...newList]);
+        ctx.emit("change", uploadFile);
+        try {
+          const result = await props2.request(raw, (percent) => {
+            const current2 = newList.find((f) => f.uid === uploadFile.uid);
+            if (current2) {
+              const i = newList.indexOf(current2);
+              newList[i] = {
+                ...current2,
+                percent
+              };
+              ctx.emit("update:fileList", [...newList]);
+            }
+          });
+          const current = newList.find((f) => f.uid === uploadFile.uid);
+          if (current) {
+            const localUrl = objectUrlMap.value.get(uploadFile.uid);
+            if (localUrl) {
+              URL.revokeObjectURL(localUrl);
+              objectUrlMap.value.delete(uploadFile.uid);
+            }
+            const i = newList.indexOf(current);
+            newList[i] = {
+              ...current,
+              status: "success",
+              percent: 100,
+              url: result.url
+            };
+            ctx.emit("update:fileList", [...newList]);
+            ctx.emit("change", newList[i]);
+          }
+        } catch (e) {
+          const current = newList.find((f) => f.uid === uploadFile.uid);
+          if (current) {
+            const i = newList.indexOf(current);
+            newList[i] = {
+              ...current,
+              status: "error"
+            };
+            ctx.emit("update:fileList", [...newList]);
+            ctx.emit("error", {
+              file: raw,
+              message: String(e)
+            });
+          }
+        }
+      }
+    };
+    const onInputChange = (e) => {
+      const target = e.target;
+      if (target.files) {
+        processFiles(target.files);
+        target.value = "";
+      }
+    };
+    const onDragOver = (e) => {
+      if (props2.disabled || !props2.drag) return;
+      e.preventDefault();
+      isDragOver.value = true;
+    };
+    const onDragLeave = () => {
+      isDragOver.value = false;
+    };
+    const onDrop = (e) => {
+      var _a;
+      if (props2.disabled || !props2.drag) return;
+      e.preventDefault();
+      isDragOver.value = false;
+      if ((_a = e.dataTransfer) == null ? void 0 : _a.files) {
+        processFiles(e.dataTransfer.files);
+      }
+    };
+    const removeFile = (uid) => {
+      const localUrl = objectUrlMap.value.get(uid);
+      if (localUrl) {
+        URL.revokeObjectURL(localUrl);
+        objectUrlMap.value.delete(uid);
+      }
+      const next = props2.fileList.filter((f) => f.uid !== uid);
+      ctx.emit("update:fileList", next);
+    };
+    return () => {
+      const cardStyle = {
+        width: props2.previewSize,
+        height: props2.previewSize
+      };
+      const previewCards = props2.fileList.map((file) => {
+        const previewUrl = getPreviewUrl(file);
+        const statusClass = `k-image-upload-card--${file.status}`;
+        return createVNode("div", {
+          "key": file.uid,
+          "class": ["k-image-upload-card", statusClass],
+          "style": cardStyle
+        }, [previewUrl && createVNode("img", {
+          "class": "k-image-upload-preview",
+          "src": previewUrl,
+          "alt": file.name
+        }, null), file.status === "uploading" && createVNode("div", {
+          "class": "k-image-upload-overlay"
+        }, [createVNode("div", {
+          "class": "k-image-upload-progress",
+          "style": {
+            height: `${file.percent}%`
+          }
+        }, null), createVNode("span", {
+          "class": "k-image-upload-percent"
+        }, [file.percent, createTextVNode("%")])]), file.status === "error" && createVNode("div", {
+          "class": "k-image-upload-overlay k-image-upload-overlay--error"
+        }, [createVNode("span", null, [createTextVNode("上传失败")])]), !props2.disabled && createVNode("button", {
+          "class": "k-image-upload-remove",
+          "type": "button",
+          "onClick": (e) => {
+            e.stopPropagation();
+            removeFile(file.uid);
+          }
+        }, [createTextVNode("×")])]);
+      });
+      const addCard = showAddCard.value && createVNode("div", {
+        "class": ["k-image-upload-card", "k-image-upload-card--add", isDragOver.value ? "k-upload-drag-over" : ""].filter(Boolean),
+        "style": cardStyle,
+        "onClick": openFileDialog,
+        "onDragover": onDragOver,
+        "onDragleave": onDragLeave,
+        "onDrop": onDrop
+      }, [createVNode("span", {
+        "class": "k-image-upload-add-icon"
+      }, [createTextVNode("+")])]);
+      return createVNode("div", {
+        "class": ["k-image-upload", props2.disabled ? "k-upload-disabled" : ""].filter(Boolean)
+      }, [createVNode("input", {
+        "ref": inputRef,
+        "type": "file",
+        "class": "k-upload-input",
+        "accept": props2.accept,
+        "multiple": props2.multiple,
+        "onChange": onInputChange
+      }, null), createVNode("div", {
+        "class": "k-image-upload-grid"
+      }, [previewCards, addCard])]);
+    };
+  }
+});
+const STATUS_TEXT = {
+  pending: "等待中",
+  uploading: "上传中",
+  success: "已完成",
+  error: "上传失败"
+};
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+const KFileList = /* @__PURE__ */ defineComponent({
+  name: "KFileList",
+  props: {
+    files: {
+      type: Array,
+      default: () => []
+    },
+    removable: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ["remove"],
+  setup(props2, ctx) {
+    return () => {
+      if (props2.files.length === 0) return null;
+      return createVNode("ul", {
+        "class": "k-file-list"
+      }, [props2.files.map((file) => {
+        const statusClass = `k-file-list-item--${file.status}`;
+        return createVNode("li", {
+          "key": file.uid,
+          "class": ["k-file-list-item", statusClass]
+        }, [createVNode("span", {
+          "class": "k-file-list-icon",
+          "aria-hidden": "true"
+        }, [file.status === "success" ? "✓" : file.status === "error" ? "✕" : "○"]), createVNode("div", {
+          "class": "k-file-list-info"
+        }, [createVNode("span", {
+          "class": "k-file-list-name",
+          "title": file.name
+        }, [file.url ? createVNode("a", {
+          "class": "k-file-list-link",
+          "href": file.url,
+          "target": "_blank",
+          "rel": "noopener noreferrer"
+        }, [file.name]) : file.name]), createVNode("span", {
+          "class": "k-file-list-meta"
+        }, [formatSize(file.size), createTextVNode(" · "), STATUS_TEXT[file.status]])]), props2.removable && createVNode("button", {
+          "class": "k-file-list-remove",
+          "type": "button",
+          "title": "移除文件",
+          "onClick": () => ctx.emit("remove", file)
+        }, [createTextVNode("×")]), file.status === "uploading" && createVNode("div", {
+          "class": "k-file-list-progress-track"
+        }, [createVNode("div", {
+          "class": "k-file-list-progress-fill",
+          "style": {
+            width: `${file.percent}%`
+          }
+        }, null)])]);
+      })]);
+    };
+  }
+});
+function defineCrudRoutes(config) {
+  const { name, path, permission, title, icon } = config;
+  const resource = permission ?? name.toLowerCase();
+  const basePath = path.replace(/\/+$/, "");
+  const opSpecs = [
+    { op: "list", suffix: "", action: "read", component: config.list, titleSuffix: "", keepAlive: true, hidden: false },
+    { op: "new", suffix: "/new", action: "create", component: config.new, titleSuffix: " - 新建", keepAlive: false, hidden: true },
+    { op: "modify", suffix: "/:id/edit", action: "update", component: config.modify, titleSuffix: " - 编辑", keepAlive: false, hidden: true },
+    { op: "detail", suffix: "/:id", action: "read", component: config.detail, titleSuffix: " - 详情", keepAlive: false, hidden: true }
+  ];
+  const routes = [];
+  for (const spec of opSpecs) {
+    if (!spec.component) continue;
+    routes.push({
+      path: basePath + spec.suffix,
+      // 路由名称格式：EntityOp，如 OrderList、OrderNew
+      name: `${name}${capitalize(spec.op)}`,
+      component: spec.component,
+      meta: {
+        crud: {
+          entity: name,
+          op: spec.op
+        },
+        // 仅在显式传入 permission 时生成权限检查
+        ...permission ? { can: { resource, action: spec.action } } : void 0,
+        requiresAuth: true,
+        // 自动填充 title：基于 config.title + 操作类型后缀
+        ...title ? { title: `${title}${spec.titleSuffix}` } : void 0,
+        // 继承 config.icon
+        ...icon ? { icon } : void 0,
+        keepAlive: spec.keepAlive,
+        hidden: spec.hidden
+      }
+    });
+  }
+  return routes;
+}
+function capitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+const TAB_STORE_KEY = Symbol("tab-store");
+function createTabStoreInstance() {
+  const tabs = ref([]);
+  const activeTab = ref("");
+  const cachedNames = computed(
+    () => tabs.value.map((tab) => tab.name)
+  );
+  const addTab = (tab) => {
+    const exists = tabs.value.some((t) => t.path === tab.path);
+    if (!exists) {
+      tabs.value.push(tab);
+    }
+    activeTab.value = tab.path;
+  };
+  const addTabFromRoute2 = (route) => {
+    const meta = route.meta;
+    const title = meta.title ?? (typeof route.name === "string" ? route.name : route.path);
+    const name = typeof route.name === "string" ? route.name : route.path;
+    addTab({
+      path: route.path,
+      title,
+      name,
+      closable: true
+    });
+  };
+  const removeTab = (path) => {
+    const index = tabs.value.findIndex((t) => t.path === path);
+    if (index === -1) return void 0;
+    const target = tabs.value[index];
+    if (!target.closable) return void 0;
+    tabs.value.splice(index, 1);
+    if (activeTab.value === path) {
+      const nextTab = tabs.value[index] ?? tabs.value[index - 1];
+      activeTab.value = nextTab ? nextTab.path : "";
+      return activeTab.value || void 0;
+    }
+    return void 0;
+  };
+  const removeOthers = (path) => {
+    tabs.value = tabs.value.filter((t) => !t.closable || t.path === path);
+    if (!tabs.value.some((t) => t.path === activeTab.value)) {
+      activeTab.value = path;
+    }
+  };
+  const removeAll = () => {
+    tabs.value = tabs.value.filter((t) => !t.closable);
+    const first = tabs.value[0];
+    activeTab.value = first ? first.path : "";
+  };
+  const setActive = (path) => {
+    activeTab.value = path;
+  };
+  return {
+    tabs,
+    activeTab,
+    cachedNames,
+    addTab,
+    addTabFromRoute: addTabFromRoute2,
+    removeTab,
+    removeOthers,
+    removeAll,
+    setActive
+  };
+}
+function createTabStore() {
+  const store = createTabStoreInstance();
+  provide(TAB_STORE_KEY, store);
+  return store;
+}
+function useTabStore() {
+  const store = inject(TAB_STORE_KEY);
+  if (!store) {
+    throw new Error(
+      "[useTabStore] 未找到 tab store 实例，请确保在父级组件中调用了 createTabStore()"
+    );
+  }
+  return store;
+}
+function useMenuFromRoutes(routes) {
+  return computed(() => transformRoutes(routes));
+}
+function transformRoutes(routes) {
+  var _a;
+  const result = [];
+  for (const route of routes) {
+    const meta = route.meta;
+    if (meta == null ? void 0 : meta.hidden) continue;
+    const label = meta == null ? void 0 : meta.title;
+    if (!label) continue;
+    const key = typeof route.name === "string" ? route.name : route.path;
+    const item = {
+      key,
+      label,
+      path: route.path,
+      icon: meta == null ? void 0 : meta.icon
+    };
+    if ((_a = route.children) == null ? void 0 : _a.length) {
+      const children = transformRoutes(route.children);
+      if (children.length > 0) {
+        item.children = children;
+        delete item.path;
+      }
+    }
+    result.push(item);
+  }
+  return result.sort((a, b) => {
+    const sortA = findSort(routes, a.key);
+    const sortB = findSort(routes, b.key);
+    return sortA - sortB;
+  });
+}
+function findSort(routes, key) {
+  var _a;
+  for (const route of routes) {
+    const routeKey = typeof route.name === "string" ? route.name : route.path;
+    if (routeKey === key) {
+      return ((_a = route.meta) == null ? void 0 : _a.sort) ?? Infinity;
+    }
+  }
+  return Infinity;
+}
+function createRouterGuard(options) {
+  const {
+    auth,
+    tabStore,
+    loginPath = "/login",
+    forbiddenPath = "/403"
+  } = options;
+  return (to) => {
+    const meta = to.meta;
+    if (to.path === loginPath && auth.isAuthenticated.value) {
+      return "/";
+    }
+    if (meta.can) {
+      const { resource, action } = meta.can;
+      if (!auth.can(resource, action)) {
+        if (to.path === forbiddenPath) return void 0;
+        return forbiddenPath;
+      }
+    }
+    const requiresAuth = meta.requiresAuth !== false;
+    if (requiresAuth && !auth.isAuthenticated.value) {
+      if (to.path === loginPath) return void 0;
+      return loginPath;
+    }
+    if (tabStore) {
+      addTabFromRoute(tabStore, to);
+    }
+    return void 0;
+  };
+}
+function addTabFromRoute(tabStore, route) {
+  const meta = route.meta;
+  const title = meta.title ?? (typeof route.name === "string" ? route.name : route.path);
+  const name = typeof route.name === "string" ? route.name : route.path;
+  tabStore.addTab({
+    path: route.path,
+    title,
+    name,
+    closable: true
+  });
+}
+function parseResponseHeaders(rawHeaders) {
+  const headers = {};
+  if (!rawHeaders) return headers;
+  rawHeaders.split("\r\n").forEach((line) => {
+    const idx = line.indexOf(":");
+    if (idx > 0) {
+      const key = line.slice(0, idx).trim().toLowerCase();
+      const value = line.slice(idx + 1).trim();
+      headers[key] = value;
+    }
+  });
+  return headers;
+}
+class XhrTransport {
+  send(request) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open(request.method, request.url, true);
+      for (const [key, value] of Object.entries(request.headers)) {
+        xhr.setRequestHeader(key, value);
+      }
+      if (request.timeout !== void 0 && request.timeout > 0) {
+        xhr.timeout = request.timeout;
+      }
+      if (request.onUploadProgress) {
+        const onProgress = request.onUploadProgress;
+        xhr.upload.addEventListener("progress", (event) => {
+          if (event.lengthComputable) {
+            onProgress({ loaded: event.loaded, total: event.total });
+          }
+        });
+      }
+      if (request.signal) {
+        if (request.signal.aborted) {
+          xhr.abort();
+          reject({ type: "aborted" });
+          return;
+        }
+        request.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+      }
+      xhr.onload = () => {
+        const headers = parseResponseHeaders(xhr.getAllResponseHeaders());
+        const responseText = xhr.responseText;
+        const response = {
+          status: xhr.status,
+          statusText: xhr.statusText,
+          headers,
+          body: null,
+          text: () => Promise.resolve(responseText),
+          json: () => Promise.resolve(JSON.parse(responseText)),
+          blob: () => Promise.resolve(new Blob([responseText]))
+        };
+        resolve(response);
+      };
+      xhr.onerror = () => {
+        reject({ type: "unknown", error: new Error("网络错误") });
+      };
+      xhr.ontimeout = () => {
+        reject({ type: "timeout" });
+      };
+      xhr.onabort = () => {
+        reject({ type: "aborted" });
+      };
+      xhr.send(request.body);
+    });
+  }
+}
+function topologicalSort(nodes) {
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    inDegree.set(node.id, 0);
+    adjacency.set(node.id, []);
+  }
+  for (const node of nodes) {
+    for (const dep of node.dependencies) {
+      if (!nodeMap.has(dep)) {
+        throw new Error(`[orchestrator] 节点 "${node.id}" 依赖的 "${dep}" 不存在`);
+      }
+      adjacency.get(dep).push(node.id);
+      inDegree.set(node.id, (inDegree.get(node.id) ?? 0) + 1);
+    }
+  }
+  const layers = [];
+  let queue = nodes.filter((n) => inDegree.get(n.id) === 0).map((n) => n.id);
+  while (queue.length > 0) {
+    layers.push([...queue]);
+    const nextQueue = [];
+    for (const id of queue) {
+      for (const neighbor of adjacency.get(id)) {
+        const degree = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, degree);
+        if (degree === 0) {
+          nextQueue.push(neighbor);
+        }
+      }
+    }
+    queue = nextQueue;
+  }
+  const totalSorted = layers.reduce((sum, layer) => sum + layer.length, 0);
+  if (totalSorted !== nodes.length) {
+    throw new Error("[orchestrator] 检测到循环依赖");
+  }
+  return layers;
+}
+async function orchestrate(nodes, failureStrategy = "failFast") {
+  if (nodes.length === 0) {
+    return { results: /* @__PURE__ */ new Map(), errors: /* @__PURE__ */ new Map() };
+  }
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  const layers = topologicalSort(nodes);
+  const results = /* @__PURE__ */ new Map();
+  const errors = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    const tasks = layer.map(async (id) => {
+      const node = nodeMap.get(id);
+      try {
+        const result = await node.execute();
+        results.set(id, result);
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e));
+        errors.set(id, error);
+        if (failureStrategy === "failFast") {
+          throw error;
+        }
+      }
+    });
+    if (failureStrategy === "failFast") {
+      await Promise.all(tasks);
+    } else {
+      await Promise.allSettled(tasks);
+    }
+  }
+  return { results, errors };
+}
+function createNode(id, execute, dependencies = []) {
+  return { id, execute, dependencies };
+}
+function after(...deps) {
+  return (id, execute) => {
+    return { id, execute, dependencies: deps };
+  };
+}
+function useRequest(client) {
+  const controllers = [];
+  onUnmounted(() => {
+    for (const controller of controllers) {
+      controller.abort("组件已卸载");
+    }
+    controllers.length = 0;
+  });
+  const proxiedClient = {
+    ...client,
+    registerAbortController: (controller) => {
+      controllers.push(controller);
+      client.registerAbortController(controller);
+    }
+  };
+  return proxiedClient;
+}
+function usePolling(fn, interval) {
+  const data = ref();
+  const isPolling = ref(false);
+  const error = ref(null);
+  let timer = null;
+  async function tick() {
+    try {
+      const result = await fn();
+      data.value = result;
+      error.value = null;
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+    }
+    if (isPolling.value) {
+      timer = setTimeout(tick, interval);
+    }
+  }
+  function start() {
+    if (isPolling.value) return;
+    isPolling.value = true;
+    tick();
+  }
+  function stop() {
+    isPolling.value = false;
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  onUnmounted(stop);
+  return { data, isPolling, error, start, stop };
+}
+function useBatchLoader(batchFn, options = {}) {
+  const windowMs = options.windowMs ?? 16;
+  const maxBatchSize = options.maxBatchSize ?? 100;
+  let queue = [];
+  let timer = null;
+  async function executeBatch(batch) {
+    try {
+      const keys = batch.map((e) => e.key);
+      const values = await batchFn(keys);
+      if (values.length !== batch.length) {
+        const error = new Error(`[useBatchLoader] 批量函数返回 ${values.length} 个结果，期望 ${batch.length} 个`);
+        batch.forEach((e) => e.reject(error));
+        return;
+      }
+      batch.forEach((entry, i) => entry.resolve(values[i]));
+    } catch (e) {
+      batch.forEach((entry) => entry.reject(e));
+    }
+  }
+  function scheduleFlush() {
+    if (timer !== null) return;
+    timer = setTimeout(() => {
+      timer = null;
+      flush();
+    }, windowMs);
+  }
+  function flush() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    while (queue.length > 0) {
+      const batch = queue.splice(0, maxBatchSize);
+      executeBatch(batch);
+    }
+  }
+  function load(key) {
+    return new Promise((resolve, reject) => {
+      queue.push({ key, resolve, reject });
+      if (queue.length >= maxBatchSize) {
+        flush();
+      } else {
+        scheduleFlush();
+      }
+    });
+  }
+  onUnmounted(() => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    queue.forEach((e) => e.reject(new Error("组件已卸载")));
+    queue = [];
+  });
+  return { load, flush };
+}
+function createUploader(uploaderOptions = {}) {
+  const transport = new XhrTransport();
+  function buildURL(url) {
+    if (url.startsWith("http")) return url;
+    return `${uploaderOptions.baseURL ?? ""}${url}`;
+  }
+  function buildHeaders(options) {
+    var _a;
+    const headers = { ...uploaderOptions.headers, ...options.headers };
+    const token = (_a = uploaderOptions.getToken) == null ? void 0 : _a.call(uploaderOptions);
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  function doUpload(formData, options) {
+    const progress = ref(0);
+    const abortController = new AbortController();
+    const promise = transport.send({
+      url: buildURL(options.url),
+      method: "POST",
+      headers: buildHeaders(options),
+      body: formData,
+      signal: abortController.signal,
+      onUploadProgress: (event) => {
+        var _a;
+        const percent = event.total > 0 ? Math.round(event.loaded / event.total * 100) : 0;
+        progress.value = percent;
+        (_a = options.onProgress) == null ? void 0 : _a.call(options, percent);
+      }
+    }).then(async (response) => {
+      if (response.status < 200 || response.status >= 300) {
+        throw new NetworkRequestError({
+          type: "httpError",
+          status: response.status,
+          statusText: response.statusText
+        });
+      }
+      const contentType = response.headers["content-type"] ?? "";
+      if (contentType.includes("application/json")) {
+        const json = await response.json();
+        if (isWrappedResponse(json)) {
+          if (!json.success) throw new BusinessError(json.message || "上传失败");
+          return json.data;
+        }
+        return json;
+      }
+      return await response.text();
+    });
+    return {
+      progress,
+      abort: () => abortController.abort("上传已取消"),
+      promise
+    };
+  }
+  return {
+    upload(file, options) {
+      const fieldName = options.fieldName ?? "file";
+      const formData = new FormData();
+      formData.append(fieldName, file);
+      if (options.data) {
+        for (const [key, value] of Object.entries(options.data)) {
+          formData.append(key, value);
+        }
+      }
+      return doUpload(formData, options);
+    },
+    uploadMultiple(files, options) {
+      const fieldName = options.fieldName ?? "files";
+      const formData = new FormData();
+      files.forEach((file) => formData.append(fieldName, file));
+      if (options.data) {
+        for (const [key, value] of Object.entries(options.data)) {
+          formData.append(key, value);
+        }
+      }
+      return doUpload(formData, options);
+    }
+  };
+}
+function isWrappedResponse(value) {
+  return typeof value === "object" && value !== null && "success" in value && "data" in value && typeof value.success === "boolean";
+}
+function defineUserStore(options) {
+  const { loginApi, onLoginSuccess, onLogoutSuccess } = options;
+  const useStore = defineStore("kine-user", () => {
+    const auth = useAuth();
+    const user = computed(() => auth.user.value);
+    const isLoggedIn = computed(() => auth.isAuthenticated.value);
+    const token = computed(() => auth.token.value);
+    const permissions = computed(() => auth.permissions.value);
+    function can(resource, action, scope) {
+      return auth.can(resource, action, scope);
+    }
+    async function login(account, password) {
+      const result = await loginApi({ account, password });
+      auth.loginWith(result);
+      onLoginSuccess == null ? void 0 : onLoginSuccess();
+    }
+    function logout() {
+      auth.logout();
+      onLogoutSuccess == null ? void 0 : onLogoutSuccess();
+    }
+    async function initUser() {
+      await auth.restore();
+    }
+    return { user, isLoggedIn, token, permissions, can, login, logout, initUser };
+  });
+  return useStore;
+}
+export {
+  BusinessError,
+  ControlGate,
+  FetchTransport,
+  KContent,
+  KFileList,
+  KHeader,
+  KImageUpload,
+  KLayout,
+  KLoginPage,
+  KNavMenu,
+  KPageHeader,
+  KSearchTable,
+  KSider,
+  KUpload,
+  LAYOUT_COLLAPSED_KEY,
+  LAYOUT_COLLAPSED_WIDTH_KEY,
+  LAYOUT_SIDER_WIDTH_KEY,
+  LAYOUT_TOGGLE_KEY,
+  NetworkRequestError,
+  REQUEST_CLIENT_KEY,
+  RequestBuilder,
+  XhrTransport,
+  addTabFromRoute,
+  after,
+  createAuth,
+  createAuthGuard,
+  createCrudApp,
+  createDefaultRequest,
+  createNode,
+  createPermissiveRequest,
+  createQueryClient,
+  createRequest,
+  createRouterGuard,
+  createStrictRequest,
+  createTabStore,
+  createUploader,
+  createVCan,
+  defineCrudRoutes,
+  defineRepository,
+  defineUserStore,
+  orchestrate,
+  setupCrud,
+  useAuth,
+  useBatchLoader,
+  useMenuFromRoutes,
+  usePolling,
+  useRequest,
+  useRequestClient,
+  useTabStore
+};