@dt-frames/ui 3.0.1 → 4.0.1

package/dist/es/layout/src/components/menu/basic-menu/NoramalMenu.d.ts

@@ -0,0 +1,14 @@
+import { MenuRecordRaw, NormalProps } from '../../../types/menu.type';
+declare const _default: import('vue').DefineComponent<NormalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (args_0: MenuRecordRaw) => any;
+    enter: (args_0: MenuRecordRaw) => any;
+}, string, import('vue').PublicProps, Readonly<NormalProps> & Readonly<{
+    onSelect?: ((args_0: MenuRecordRaw) => any) | undefined;
+    onEnter?: ((args_0: MenuRecordRaw) => any) | undefined;
+}>, {
+    theme: "dark" | "light";
+    activePath: string;
+    collapse: boolean;
+    menus: MenuRecordRaw[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLUListElement>;
+export default _default;

package/dist/es/layout/src/components/menu/basic-menu/SubMenu.d.ts

@@ -0,0 +1,6 @@
+import { MenuRecordRaw } from '../../../types/menu.type';
+type __VLS_Props = {
+    menu: MenuRecordRaw;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/es/layout/src/components/menu/basic-menu/SubMenuCom.d.ts

@@ -0,0 +1,25 @@
+import { SubMenuProps } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        title?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SubMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SubMenuProps> & Readonly<{}>, {
+    disabled: boolean;
+    isSubMenuMore: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLIElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/layout/src/components/menu/basic-menu/SubMenuContent.d.ts

@@ -0,0 +1,27 @@
+import { MenuItemProps } from './type';
+interface Props extends MenuItemProps {
+    isMenuMore?: boolean;
+    isTopLevelMenuSubmenu: boolean;
+    level?: number;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        title?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    isMenuMore: boolean;
+    level: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/layout/src/components/menu/basic-menu/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Menu } from './Menu';
+export { Menu };

package/dist/es/layout/src/components/menu/basic-menu/type.d.ts

@@ -0,0 +1,127 @@
+import { Ref } from 'vue';
+import { MenuRecordBadgeRaw, MenuRecordRaw, IconType } from '../../../types/menu.type';
+import { ThemeModeType } from '../../../types/perferences.type';
+type MenuProps = {
+    /**
+     * @zh_CN 是否开启手风琴模式
+     * @default true
+     */
+    accordion?: boolean;
+    /**
+     * @zh_CN 菜单是否折叠
+     * @default false
+     */
+    collapse?: boolean;
+    /**
+     * @zh_CN 菜单折叠时是否显示菜单名称
+     * @default false
+     */
+    collapseShowTitle?: boolean;
+    /**
+     * 默认激活的菜单
+     */
+    defaultActive?: string;
+    /**
+     * 默认展开的菜单
+     */
+    defaultOpeneds?: string[];
+    /**
+     * 菜单模式
+     */
+    mode?: 'horizontal' | 'vertical';
+    /**
+     * 是否圆润风格
+     */
+    rounded?: boolean;
+    /**
+     * 是否自动滚动到激活的菜单项
+     */
+    scrollToActive?: boolean;
+    /**
+     * 菜单主题
+     */
+    theme?: ThemeModeType;
+    /**
+     * 菜单
+     */
+    menus?: MenuRecordRaw[];
+};
+type SubMenuProps = MenuRecordBadgeRaw & {
+    /**
+     * 激活图标
+     */
+    activeIcon?: string;
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 图标
+     */
+    icon?: string;
+    /**
+     * 图标类型
+     */
+    iconType?: IconType;
+    /**
+     * submenu 名称
+     */
+    path: string;
+    isSubMenuMore?: boolean;
+};
+interface MenuItemProps extends MenuRecordBadgeRaw {
+    /**
+     * 图标
+     */
+    activeIcon?: string;
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 图标
+     */
+    icon?: string;
+    /**
+     * 图标类型
+     */
+    iconType?: IconType;
+    /**
+     * 名称
+     */
+    path: string;
+}
+type MenuItemRegistered = {
+    active: boolean;
+    parentPaths: string[];
+    path: string;
+};
+type MenuItemClicked = {
+    parentPaths: string[];
+    path: string;
+};
+type MenuProvider = {
+    activePath?: string;
+    addMenuItem: (item: MenuItemRegistered) => void;
+    addSubMenu: (item: MenuItemRegistered) => void;
+    closeMenu: (path: string, parentLinks: string[]) => void;
+    handleMenuItemClick: (item: MenuItemClicked) => void;
+    handleSubMenuClick: (subMenu: MenuItemRegistered) => void;
+    isMenuPopup: boolean;
+    items: Record<string, MenuItemRegistered>;
+    openedMenus: string[];
+    openMenu: (path: string, parentLinks: string[]) => void;
+    props: MenuProps;
+    removeMenuItem: (item: MenuItemRegistered) => void;
+    removeSubMenu: (item: MenuItemRegistered) => void;
+    subMenus: Record<string, MenuItemRegistered>;
+    theme: string;
+};
+interface SubMenuProvider {
+    addSubMenu: (item: MenuItemRegistered) => void;
+    handleMouseleave?: (deepDispatch: boolean) => void;
+    level: number;
+    mouseInChild: Ref<boolean>;
+    removeSubMenu: (item: MenuItemRegistered) => void;
+}
+export type { MenuProps, MenuProvider, MenuItemRegistered, MenuItemClicked, SubMenuProvider, SubMenuProps, MenuItemProps };

package/dist/es/layout/src/components/menu/hooks/useMenu.d.ts

@@ -0,0 +1,9 @@
+import { SubMenuProvider } from '../basic-menu/type';
+declare function useMenu(): {
+    parentPaths: import('vue').ComputedRef<string[]>;
+    parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance | null>;
+};
+declare function useMenuStyle(menu?: SubMenuProvider): import('vue').ComputedRef<{
+    '--menu-level': number;
+}>;
+export { useMenu, useMenuStyle };

package/dist/es/layout/src/components/menu/hooks/useMenuScroll.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+interface UseMenuScrollOptions {
+    delay?: number;
+    enable?: boolean | Ref<boolean>;
+}
+export declare function useMenuScroll(activePath: Ref<string | undefined>, options?: UseMenuScrollOptions): {
+    scrollToActiveItem: () => void;
+};
+export {};

package/dist/es/layout/src/components/tabbar/Tabbar.d.ts

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    showIcon?: boolean;
+    theme?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/es/layout/src/components/tabbar/hooks/useTab.d.ts

@@ -0,0 +1,25 @@
+import { RouteLocationNormalized } from 'vue-router';
+import { ComputedRef } from 'vue';
+export declare function useTabs(): {
+    closeAllTabs: () => Promise<void>;
+    closeCurrentTab: (tab?: RouteLocationNormalized) => Promise<void>;
+    closeLeftTabs: (tab?: RouteLocationNormalized) => Promise<void>;
+    closeOtherTabs: (tab?: RouteLocationNormalized) => Promise<void>;
+    closeRightTabs: (tab?: RouteLocationNormalized) => Promise<void>;
+    closeTabByKey: (key: string) => Promise<void>;
+    getTabDisableState: (tab?: RouteLocationNormalized) => {
+        disabledCloseAll: boolean;
+        disabledCloseCurrent: boolean;
+        disabledCloseLeft: boolean;
+        disabledCloseOther: boolean;
+        disabledCloseRight: boolean;
+        disabledRefresh: boolean;
+    };
+    openTabInNewWindow: (tab?: RouteLocationNormalized) => Promise<void>;
+    pinTab: (tab?: RouteLocationNormalized) => Promise<void>;
+    refreshTab: (name?: string) => Promise<void>;
+    resetTabTitle: () => Promise<void>;
+    setTabTitle: (title: ComputedRef<string> | string) => Promise<void>;
+    toggleTabPin: (tab?: RouteLocationNormalized) => Promise<void>;
+    unpinTab: (tab?: RouteLocationNormalized) => Promise<void>;
+};

package/dist/es/layout/src/components/tabbar/hooks/useTabbar.d.ts

@@ -0,0 +1,15 @@
+import { IContextMenuItem, TabDefinition } from '../tabsView/types';
+/**
+ * 主体区域最大化
+ */
+export declare function useContentMaximize(): {
+    contentIsMaximize: import('vue').ComputedRef<boolean | undefined>;
+    toggleMaximize: () => void;
+};
+export declare function useTabbar(): {
+    createContextMenus: (tab: TabDefinition) => IContextMenuItem[];
+    currentActive: import('vue').ComputedRef<string>;
+    currentTabs: import('vue').Ref<TabDefinition[] | undefined, TabDefinition[] | undefined>;
+    handleClick: (key: string) => void;
+    handleClose: (key: string) => Promise<void>;
+};

package/dist/es/layout/src/components/tabbar/hooks/useTabsDrag.d.ts

@@ -0,0 +1,8 @@
+import { TabsProps } from '../tabsView/types';
+import { SortableOptions, default as Sortable } from 'sortablejs';
+declare function useSortable<T extends HTMLElement>(sortableContainer: T, options?: SortableOptions): {
+    initializeSortable: () => Promise<Sortable>;
+};
+export { useSortable };
+export type { Sortable };
+export declare function useTabsDrag(props: Partial<TabsProps>, emit: any): void;

package/dist/es/layout/src/components/tabbar/hooks/useTabsViewScroll.d.ts

@@ -0,0 +1,11 @@
+import { TabsProps } from '../tabsView/types';
+export declare function useTabsViewScroll(props: TabsProps): {
+    handleScrollAt: import('@vueuse/shared').UseDebounceFnReturn<({ left, right }: any) => void>;
+    handleWheel: ({ deltaY }: WheelEvent) => void;
+    initScrollbar: () => Promise<void>;
+    scrollbarRef: import('vue').Ref<any, any>;
+    scrollDirection: (direction: "left" | "right", distance?: number) => void;
+    scrollIsAtLeft: import('vue').Ref<boolean, boolean>;
+    scrollIsAtRight: import('vue').Ref<boolean, boolean>;
+    showScrollButton: import('vue').Ref<boolean, boolean>;
+};