ele-admin-plus 1.0.0-beta.1

package/es/ele-pro-layout/types/index.d.ts

@@ -0,0 +1,215 @@
+import type { RouteMeta, RouteLocationMatched } from 'vue-router';
+import type { MenuProps, BreadcrumbProps } from 'element-plus';
+import type { MenuItem as MenuItemProps } from '../../ele-menus/types';
+/**
+ * 菜单元数据
+ */
+export interface MenuMeta extends RouteMeta {
+    /** 菜单标题 */
+    title?: string;
+    /** 菜单图标 */
+    icon?: string;
+    /** 菜单是否隐藏 */
+    hide?: boolean;
+    /** 选中其它菜单 */
+    active?: string;
+    /** 是否隐藏页脚 */
+    hideFooter?: boolean;
+    /** 是否隐藏侧栏 */
+    hideSidebar?: boolean;
+    /** 是否隐藏双侧栏一级 */
+    hideSidebox?: boolean;
+    /** 页签是否可关闭 */
+    closable?: boolean;
+    /** 页签不同参数是否合并 */
+    tabUnique?: boolean;
+    /** 页签是否缓存 */
+    keepAlive?: boolean;
+    /** 是否在面包屑中显示 */
+    breadcrumb?: boolean;
+    /** 菜单组件其它属性 */
+    props?: Partial<MenuItemProps>;
+    /** 路由地址 */
+    routePath?: string;
+    /** 内链地址, 内部属性 */
+    iframe?: string;
+}
+/**
+ * 菜单数据
+ */
+export interface MenuItem {
+    /** 路由名称 */
+    name?: string;
+    /** 路由地址 */
+    path: string;
+    /** 路由组件 */
+    component?: string;
+    /** 路由重定向 */
+    redirect?: string;
+    /** 路由元数据 */
+    meta?: MenuMeta;
+    /** 子路由 */
+    children?: Array<MenuItem>;
+    /** 临时子路由数据, 内部属性 */
+    tempChildren?: Array<MenuItem>;
+}
+/**
+ * 页签数据
+ */
+export interface TabItem {
+    /** 页签标题 */
+    title?: string;
+    /** 页签标识 */
+    key?: string;
+    /** 路由地址 */
+    path?: string;
+    /** 路由完整地址 */
+    fullPath?: string;
+    /** 是否可关闭 */
+    closable?: boolean;
+    /** 是否是主页 */
+    home?: boolean;
+    /** 组件名称 */
+    components?: string[];
+    /** 路由元数据 */
+    meta?: MenuMeta;
+}
+/**
+ * 面包屑导航数据
+ */
+export interface LevelItem {
+    /** 标题 */
+    title: string;
+    /** 地址 */
+    path: string;
+}
+/**
+ * 布局类型
+ */
+export type Layout = 'side' | 'top' | 'mix';
+/**
+ * 侧栏布局类型
+ */
+export type SidebarLayout = 'default' | 'mix';
+/**
+ * 顶栏风格
+ */
+export type HeaderStyle = 'light' | 'dark' | 'primary';
+/**
+ * 侧栏风格
+ */
+export type SidebarStyle = 'light' | 'dark';
+/**
+ * 页签风格
+ */
+export type TabStyle = 'simple' | 'indicator' | 'button';
+/**
+ * 菜单标题国际化方法
+ */
+export type MenuI18n = (option: MenuI18nOption) => string | undefined | null | void;
+/**
+ * 菜单标题国际化方法参数
+ */
+export interface MenuI18nOption {
+    /** 菜单地址 */
+    path: string;
+    /** 菜单数据 */
+    menu?: MenuItem;
+    /** 当前语言 */
+    locale?: string;
+}
+/**
+ * 页签事件参数
+ */
+export interface TabItemEventOption {
+    /** 页签标识 */
+    key?: string;
+    /** 页签数据 */
+    item?: TabItem;
+    /** 当前选中页签的标识 */
+    active?: string;
+    /** 事件标识 */
+    command?: string;
+}
+/**
+ * 获取路由对应菜单的结果
+ */
+export interface MatchedResult {
+    /** 选中地址 */
+    active: string;
+    /** 菜单标题 */
+    title?: string;
+    /** 匹配的菜单数据 */
+    matched?: MenuItem[];
+    /** 是否选中非本身 */
+    activeOther: boolean;
+}
+/**
+ * 获取混合导航布局选中返回结果
+ */
+export interface MixActiveResult {
+    /** 层级一选中 */
+    active1?: string;
+    /** 层级二选中 */
+    active2?: string;
+}
+/**
+ * 主体区尺寸改变事件参数
+ */
+export interface BodySizeChangeOption {
+    /** 是否是移动设备 */
+    mobile?: boolean;
+    /** 是否是窗口尺寸改变触发 */
+    window?: boolean;
+}
+/**
+ * 窗口事件参数
+ */
+export interface WindowListenerOption {
+    /** 屏幕尺寸改变回调 */
+    onResize: () => void;
+    /** 返回键按下回调 */
+    onEscKeydown: (e: KeyboardEvent) => void;
+}
+/**
+ * 定时器实例
+ */
+export interface LayoutTimers {
+    /** 过渡动画禁用定时器 */
+    transition: number | null;
+    /** 内容区尺寸变化定时器 */
+    resize: number | null;
+}
+/**
+ * 当前路由
+ */
+export interface CurrentRoute {
+    /** 路由地址 */
+    path: string;
+    /** 路由完整地址 */
+    fullPath: string;
+    /** 路由元数据 */
+    meta: MenuMeta;
+    /** 路由匹配数据 */
+    matched: RouteLocationMatched[];
+}
+/**
+ * 菜单 tooltip 主题
+ */
+export type TooltipEffect = MenuProps['popperEffect'];
+/**
+ * 顶栏子菜单触发方式
+ */
+export type MenuTrigger = MenuProps['menuTrigger'];
+/**
+ * 面包屑导航分隔符
+ */
+export type BreadcrumbSeparator = BreadcrumbProps['separatorIcon'];
+/**
+ * 类名类型
+ */
+export type ClassSingleValue = string | Record<string, boolean | undefined>;
+/**
+ * 类名数组类型
+ */
+export type ClassValue = Array<ClassSingleValue>;

package/es/ele-pro-layout/util.d.ts

@@ -0,0 +1,99 @@
+import type { RouteLocationMatched } from 'vue-router';
+import type { MenuItem as MenuItemProps } from '../ele-menus/types';
+import type { MenuMeta, MenuItem, TabItem, LevelItem, CurrentRoute, WindowListenerOption, MatchedResult, MixActiveResult } from './types';
+/**
+ * 判断路由是否是主页
+ * @param route 路由信息
+ * @param homePath 主页地址
+ */
+export declare function isHomeRoute(route: CurrentRoute, homePath: string): boolean;
+/**
+ * 获取主页路由地址
+ * @param path 路由地址
+ */
+export declare function getHomePath(path?: string | null): string;
+/**
+ * 获取路由匹配的菜单数据
+ * @param path 路由地址
+ * @param fullPath 路由完整地址
+ * @param meta 路由元数据
+ * @param menus 菜单数据
+ */
+export declare function getRouteMatched(path: string, fullPath: string, meta: MenuMeta, menus: MenuItem[]): MatchedResult;
+/**
+ * 根据菜单地址获取菜单
+ * @param path 菜单地址
+ * @param menus 菜单数据
+ */
+export declare function findMenuByPath(path?: string, menus?: MenuItem[]): MenuItem | undefined;
+/**
+ * 根据菜单地址获取菜单及所有父级
+ * @param path 菜单地址
+ * @param menus 菜单数据
+ */
+export declare function getMatchedMenus(path: string, menus: MenuItem[], parents?: MenuItem[]): MenuItem[] | undefined;
+/**
+ * 获取面包屑导航数据
+ * @param matched 匹配的菜单数据
+ * @param activeOther 是否选中非本身
+ * @param route 路由信息
+ * @param menus 菜单数据
+ * @param tabs 页签数据
+ */
+export declare function getMatchedLevels(matched: MenuItem[] | undefined, activeOther: boolean, route: CurrentRoute, menus: MenuItem[], tabs: TabItem[]): LevelItem[];
+/**
+ * 根据路由地址获取页签数据
+ * @param path 路由地址
+ * @param tabs 全部页签数据
+ */
+export declare function findTabByPath(path?: string, tabs?: TabItem[]): TabItem | undefined;
+/**
+ * 获取路由对应的组件名称
+ * @param matched 路由匹配数据
+ */
+export declare function getMatchedComponents(matched: RouteLocationMatched[]): string[];
+/**
+ * 返回路由对应的页签数据
+ * @param current 路由信息
+ * @param tabs 当前页签数据
+ * @param homePath 主页地址
+ * @param fixedHome 是否固定主页
+ * @param repeatableTabs 可重复打开的页签
+ * @param routeTitle 路由对应的标题
+ */
+export declare function getRouteTab(current: CurrentRoute, tabs: TabItem[], homePath: string, fixedHome?: boolean, repeatableTabs?: string[], routeTitle?: string): TabItem;
+/**
+ * 获取混合导航布局选中
+ * @param matched 路由匹配的菜单层级数据
+ */
+export declare function getMixActive(matched?: MenuItem[]): MixActiveResult;
+/**
+ * 获取选中菜单的子级
+ * @param menus 菜单数据
+ * @param active 选中地址
+ */
+export declare function getActiveChilds(menus: MenuItem[], active?: string): MenuItem[];
+/**
+ * 是否是移动端
+ * @param responsive 是否开启响应式
+ */
+export declare function isMobile(responsive?: boolean): boolean;
+/**
+ * 绑定窗口事件监听
+ */
+export declare function useWindowListener(option: WindowListenerOption): void;
+/**
+ * 禁用过渡动画
+ */
+export declare function disableTransition(): number;
+/**
+ * 判断数组是否包含某个值
+ * @param array 数组
+ * @param value 值
+ */
+export declare function includes<T>(array?: T[], value?: T): boolean;
+/**
+ * 菜单数据转换
+ * @param menus 菜单数据
+ */
+export declare function getMenuItems(menus: MenuItem[]): MenuItemProps[];

package/es/ele-pro-layout/util.js

@@ -0,0 +1,216 @@
+import { onBeforeUnmount } from "vue";
+import { eachTree, screenWidth, debounce, mapTree } from "../utils/core";
+function isHomeRoute(route, homePath) {
+  return route.path === homePath || route.fullPath === homePath;
+}
+function getHomePath(path) {
+  return path || "/";
+}
+function getRouteMatched(path, fullPath, meta, menus) {
+  var _a, _b, _c;
+  if (meta == null ? void 0 : meta.active) {
+    const t = findMenuByPath(fullPath, menus) ?? findMenuByPath(path, menus);
+    return {
+      active: meta.active,
+      activeOther: true,
+      title: ((_a = t == null ? void 0 : t.meta) == null ? void 0 : _a.title) ?? meta.title,
+      matched: getMatchedMenus(meta.active, menus)
+    };
+  }
+  const temp = findMenuByPath(fullPath, menus);
+  if (temp) {
+    return {
+      active: fullPath,
+      activeOther: false,
+      title: ((_b = temp.meta) == null ? void 0 : _b.title) ?? meta.title,
+      matched: getMatchedMenus(fullPath, menus)
+    };
+  }
+  const m = findMenuByPath(path, menus);
+  return {
+    active: path,
+    activeOther: false,
+    title: ((_c = m == null ? void 0 : m.meta) == null ? void 0 : _c.title) ?? meta.title,
+    matched: getMatchedMenus(path, menus)
+  };
+}
+function findMenuByPath(path, menus) {
+  if (path == null || menus == null) {
+    return;
+  }
+  let data;
+  eachTree(menus, (d) => {
+    if (path === d.path) {
+      data = d;
+      return false;
+    }
+  });
+  return data;
+}
+function getMatchedMenus(path, menus, parents) {
+  var _a;
+  for (let i = 0; i < menus.length; i++) {
+    const m = menus[i];
+    const p = parents ? [...parents, m] : [m];
+    if (m.path === path) {
+      return p;
+    } else if ((_a = m.children) == null ? void 0 : _a.length) {
+      const result = getMatchedMenus(path, m.children, p);
+      if (result) {
+        return result;
+      }
+    }
+  }
+}
+function getMatchedLevels(matched, activeOther, route, menus, tabs) {
+  var _a;
+  const levels = [];
+  matched == null ? void 0 : matched.forEach((m) => {
+    var _a2;
+    if (m.meta && m.meta.title && m.meta.breadcrumb !== false) {
+      levels.push({
+        path: m.path,
+        title: ((_a2 = findTabByPath(m.path, tabs)) == null ? void 0 : _a2.title) || m.meta.title
+      });
+    }
+  });
+  if (activeOther) {
+    const { path, fullPath, meta } = route;
+    if ((!levels.length || fullPath !== levels[levels.length - 1].path) && meta.title) {
+      const m = findMenuByPath(fullPath, menus) ?? findMenuByPath(path, menus);
+      const t = findTabByPath(fullPath, tabs) ?? findTabByPath(path, tabs);
+      levels.push({
+        path: fullPath,
+        title: (t == null ? void 0 : t.title) || ((_a = m == null ? void 0 : m.meta) == null ? void 0 : _a.title) || meta.title
+      });
+    }
+  }
+  return levels;
+}
+function findTabByPath(path, tabs) {
+  if (path == null || tabs == null) {
+    return;
+  }
+  for (let i = 0; i < tabs.length; i++) {
+    if (path === tabs[i].key || path === tabs[i].fullPath) {
+      return tabs[i];
+    }
+  }
+}
+function getMatchedComponents(matched) {
+  const components = [];
+  matched.forEach((m) => {
+    var _a, _b;
+    if ((_b = (_a = m.components) == null ? void 0 : _a.default) == null ? void 0 : _b.name) {
+      components.push(m.components.default.name);
+    }
+  });
+  return components;
+}
+function getRouteTab(current, tabs, homePath, fixedHome, repeatableTabs, routeTitle) {
+  const { path, fullPath, meta, matched } = current;
+  const unique = meta.tabUnique === false || includes(repeatableTabs, path);
+  const key = unique ? fullPath : path;
+  const t = findTabByPath(key, tabs);
+  const title = (t == null ? void 0 : t.title) || routeTitle;
+  const home = isHomeRoute(current, homePath);
+  const isFixedHome = fixedHome && home;
+  const closable = isFixedHome ? false : (t == null ? void 0 : t.closable) ?? meta.closable !== false;
+  const components = getMatchedComponents(matched);
+  return { key, path, fullPath, title, closable, home, components, meta };
+}
+function getMixActive(matched) {
+  if (!(matched == null ? void 0 : matched.length)) {
+    return {
+      active1: void 0,
+      active2: void 0
+    };
+  }
+  const match1 = matched[0];
+  const match2 = matched.length > 1 ? matched[1] : match1;
+  return {
+    active1: match1.path,
+    active2: match2.path
+  };
+}
+function getActiveChilds(menus, active) {
+  if (!menus.length) {
+    return [];
+  }
+  if (!active) {
+    return menus[0].children || [];
+  }
+  const temp = menus.find((m) => m.path === active);
+  if (temp == null) {
+    return menus[0].children || [];
+  }
+  return temp.children || [];
+}
+function isMobile(responsive) {
+  return responsive ? screenWidth() < 768 : false;
+}
+function useWindowListener(option) {
+  const onResizeListener = debounce(() => {
+    option.onResize();
+  }, 500);
+  const onKeydownListener = (e) => {
+    if (e.keyCode === 27) {
+      option.onEscKeydown(e);
+    }
+  };
+  window.addEventListener("resize", onResizeListener);
+  window.addEventListener("keydown", onKeydownListener);
+  onBeforeUnmount(() => {
+    window.removeEventListener("resize", onResizeListener);
+    window.removeEventListener("keydown", onKeydownListener);
+  });
+}
+function disableTransition() {
+  const classes = "ele-transition-disabled";
+  document.body.classList.add(classes);
+  return setTimeout(() => {
+    document.body.classList.remove(classes);
+  }, 100);
+}
+function includes(array, value) {
+  if (array == null || value == null) {
+    return false;
+  }
+  return array.includes(value);
+}
+function getMenuItems(menus) {
+  return mapTree(menus, (m) => {
+    const { path, meta } = m;
+    const { hide, icon, title, props } = meta ?? {};
+    if (hide) {
+      return;
+    }
+    const item = {
+      title,
+      icon,
+      path,
+      index: path,
+      ...props,
+      meta
+    };
+    return item;
+  });
+}
+export {
+  disableTransition,
+  findMenuByPath,
+  findTabByPath,
+  getActiveChilds,
+  getHomePath,
+  getMatchedComponents,
+  getMatchedLevels,
+  getMatchedMenus,
+  getMenuItems,
+  getMixActive,
+  getRouteMatched,
+  getRouteTab,
+  includes,
+  isHomeRoute,
+  isMobile,
+  useWindowListener
+};

package/es/ele-pro-table/components/table-tools.d.ts

@@ -0,0 +1,43 @@
+import type { PropType } from 'vue';
+import type { Columns, TableTool, TableSize, TableLocale } from '../types';
+declare const _sfc_main: import("vue").DefineComponent<{
+    size: StringConstructor;
+    columns: PropType<Columns>;
+    tools: PropType<TableTool[]>;
+    columnSortable: BooleanConstructor;
+    columnFixed: BooleanConstructor;
+    maximized: BooleanConstructor;
+    cacheKey: StringConstructor;
+    locale: PropType<TableLocale>;
+}, {
+    lang: import("vue").ComputedRef<TableLocale>;
+    placement: import("vue").ComputedRef<"top" | "bottom">;
+    reload: () => void;
+    updateSize: (size: string) => void;
+    updateColumns: (columns: Columns) => void;
+    toggleMaximized: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    reload: () => true;
+    'update:size': (_size: TableSize) => true;
+    'update:columns': (_columns: Columns) => true;
+    'update:maximized': (_maximized: boolean) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: StringConstructor;
+    columns: PropType<Columns>;
+    tools: PropType<TableTool[]>;
+    columnSortable: BooleanConstructor;
+    columnFixed: BooleanConstructor;
+    maximized: BooleanConstructor;
+    cacheKey: StringConstructor;
+    locale: PropType<TableLocale>;
+}>> & {
+    onReload?: (() => any) | undefined;
+    "onUpdate:size"?: ((_size: "" | "default" | "small" | "large" | undefined) => any) | undefined;
+    "onUpdate:columns"?: ((_columns: Columns) => any) | undefined;
+    "onUpdate:maximized"?: ((_maximized: boolean) => any) | undefined;
+}, {
+    maximized: boolean;
+    columnSortable: boolean;
+    columnFixed: boolean;
+}, {}>;
+export default _sfc_main;