hys-ui 0.6.0 → 0.8.0

package/dist/types/components/HysTable/HysTable.vue.d.ts

@@ -20,9 +20,19 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
         "onUpdate:pageSize"?: ((size: number) => any) | undefined;
         onRowClick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
         "onUpdate:selectedRowKeys"?: ((keys: HysTableKey[]) => any) | undefined;
+        "onUpdate:currentRowKey"?: ((key: HysTableKey | null) => any) | undefined;
+        onCurrentChange?: ((row: T | undefined, previous: T | undefined) => any) | undefined;
+        onHeaderClick?: ((column: HysTableColumn<T>, event: MouseEvent) => any) | undefined;
+        onHeaderContextmenu?: ((column: HysTableColumn<T>, event: MouseEvent) => any) | undefined;
+        onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onRowContextmenu?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onCellClick?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onCellDblclick?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onCellContextmenu?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
         onSortChange?: ((sort: HysTableSort | null, sorts: HysTableSort[]) => any) | undefined;
         onPageChange?: ((page: number) => any) | undefined;
         onQueryChange?: ((query: HysTableQuery<T>) => any) | undefined;
+        "onUpdate:search"?: ((search: string) => any) | undefined;
         "onUpdate:sort"?: ((sort: HysTableSort | null) => any) | undefined;
         "onUpdate:sorts"?: ((sorts: HysTableSort[]) => any) | undefined;
         "onUpdate:filters"?: ((filters: HysTableFilters) => any) | undefined;
@@ -30,19 +40,10 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
         onSelectRange?: ((rows: T[], rangeRows: T[], checked: boolean) => any) | undefined;
         onSelectInvert?: ((rows: T[], keys: HysTableKey[]) => any) | undefined;
         onSelectNone?: (() => any) | undefined;
-        "onUpdate:currentRowKey"?: ((key: HysTableKey | null) => any) | undefined;
-        onCurrentChange?: ((row: T | undefined, previous: T | undefined) => any) | undefined;
         onChildrenChange?: ((row: T, children: readonly T[]) => any) | undefined;
         "onUpdate:expandedRowKeys"?: ((keys: HysTableKey[]) => any) | undefined;
-        onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
-        onRowContextmenu?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
-        onCellClick?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
-        onCellDblclick?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
-        onCellContextmenu?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
         onCellMouseEnter?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
         onCellMouseLeave?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
-        onHeaderClick?: ((column: HysTableColumn<T>, event: MouseEvent) => any) | undefined;
-        onHeaderContextmenu?: ((column: HysTableColumn<T>, event: MouseEvent) => any) | undefined;
         "onUpdate:filterColumnKey"?: ((key: string | null) => any) | undefined;
         onFilterOpenChange?: ((key: string | null) => any) | undefined;
         "onUpdate:columnWidths"?: ((widths: Record<string, number>) => any) | undefined;
@@ -72,6 +73,9 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
         setSort: (value: HysTableSort | readonly HysTableSort[] | null) => void;
         clearFilter: (keys?: readonly string[]) => void;
         setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
+        setSearch: (value: string) => void;
+        clearSearch: () => void;
+        focusRow: (row: T | HysTableKey) => boolean;
         showFilter: (key: string) => Promise<boolean>;
         hideFilter: () => Promise<boolean>;
         setPage: (n: number, action?: "page" | "pageSize") => void;
@@ -106,6 +110,8 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
             rows: T[];
             pageRows: T[];
             query: HysTableQuery<T>;
+            search: string;
+            setSearch: (value: string) => void;
         }) => any;
     } & {
         selection?: (props: {
@@ -1955,7 +1961,7 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
     emit: ((evt: "change", query: HysTableQuery<T>) => void) & ((evt: "select", rows: T[], row: T, checked: boolean) => void) & ((evt: "load", row: T, children: readonly T[]) => void) & ((evt: "scroll", position: {
         scrollLeft: number;
         scrollTop: number;
-    }, event: Event) => void) & ((evt: "loadError", row: T, error: unknown) => void) & ((evt: "selectionChange", rows: T[], keys: HysTableKey[]) => void) & ((evt: "selectAll", rows: T[], checked: boolean, changedRows: T[]) => void) & ((evt: "expandChange", row: T, expanded: boolean, keys: HysTableKey[]) => void) & ((evt: "update:page", page: number) => void) & ((evt: "pageSizeChange", size: number) => void) & ((evt: "update:pageSize", size: number) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysTableKey[]) => void) & ((evt: "sortChange", sort: HysTableSort | null, sorts: HysTableSort[]) => void) & ((evt: "pageChange", page: number) => void) & ((evt: "queryChange", query: HysTableQuery<T>) => void) & ((evt: "update:sort", sort: HysTableSort | null) => void) & ((evt: "update:sorts", sorts: HysTableSort[]) => void) & ((evt: "update:filters", filters: HysTableFilters) => void) & ((evt: "filterChange", filters: HysTableFilters) => void) & ((evt: "selectRange", rows: T[], rangeRows: T[], checked: boolean) => void) & ((evt: "selectInvert", rows: T[], keys: HysTableKey[]) => void) & ((evt: "selectNone") => void) & ((evt: "update:currentRowKey", key: HysTableKey | null) => void) & ((evt: "currentChange", row: T | undefined, previous: T | undefined) => void) & ((evt: "childrenChange", row: T, children: readonly T[]) => void) & ((evt: "update:expandedRowKeys", keys: HysTableKey[]) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "rowContextmenu", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellDblclick", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellContextmenu", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellMouseEnter", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellMouseLeave", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "headerClick", column: HysTableColumn<T>, event: MouseEvent) => void) & ((evt: "headerContextmenu", column: HysTableColumn<T>, event: MouseEvent) => void) & ((evt: "update:filterColumnKey", key: string | null) => void) & ((evt: "filterOpenChange", key: string | null) => void) & ((evt: "update:columnWidths", widths: Record<string, number>) => void) & ((evt: "columnResize", column: HysTableColumn<T>, width: number, previous: number) => void);
+    }, event: Event) => void) & ((evt: "loadError", row: T, error: unknown) => void) & ((evt: "selectionChange", rows: T[], keys: HysTableKey[]) => void) & ((evt: "selectAll", rows: T[], checked: boolean, changedRows: T[]) => void) & ((evt: "expandChange", row: T, expanded: boolean, keys: HysTableKey[]) => void) & ((evt: "update:page", page: number) => void) & ((evt: "pageSizeChange", size: number) => void) & ((evt: "update:pageSize", size: number) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysTableKey[]) => void) & ((evt: "update:currentRowKey", key: HysTableKey | null) => void) & ((evt: "currentChange", row: T | undefined, previous: T | undefined) => void) & ((evt: "headerClick", column: HysTableColumn<T>, event: MouseEvent) => void) & ((evt: "headerContextmenu", column: HysTableColumn<T>, event: MouseEvent) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "rowContextmenu", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellDblclick", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellContextmenu", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "sortChange", sort: HysTableSort | null, sorts: HysTableSort[]) => void) & ((evt: "pageChange", page: number) => void) & ((evt: "queryChange", query: HysTableQuery<T>) => void) & ((evt: "update:search", search: string) => void) & ((evt: "update:sort", sort: HysTableSort | null) => void) & ((evt: "update:sorts", sorts: HysTableSort[]) => void) & ((evt: "update:filters", filters: HysTableFilters) => void) & ((evt: "filterChange", filters: HysTableFilters) => void) & ((evt: "selectRange", rows: T[], rangeRows: T[], checked: boolean) => void) & ((evt: "selectInvert", rows: T[], keys: HysTableKey[]) => void) & ((evt: "selectNone") => void) & ((evt: "childrenChange", row: T, children: readonly T[]) => void) & ((evt: "update:expandedRowKeys", keys: HysTableKey[]) => void) & ((evt: "cellMouseEnter", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellMouseLeave", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "update:filterColumnKey", key: string | null) => void) & ((evt: "filterOpenChange", key: string | null) => void) & ((evt: "update:columnWidths", widths: Record<string, number>) => void) & ((evt: "columnResize", column: HysTableColumn<T>, width: number, previous: number) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysTable/tableSearch.d.ts

@@ -0,0 +1,2 @@
+import { type HysTableColumn } from "../../composables/table";
+export declare function tableSearchPredicate<T extends object>(search: string, columns: readonly HysTableColumn<T>[], keys?: readonly string[], filter?: (search: string, row: T) => boolean): ((row: T) => boolean) | undefined;

package/dist/types/components/HysTabs/HysTabs.vue.d.ts

@@ -1,95 +1,104 @@
-export type HysTabValue = string | number;
-export interface HysTabItem {
-    label: string;
-    value: HysTabValue;
-    disabled?: boolean;
-    closable?: boolean;
-    content?: string;
-    forceRender?: boolean;
-}
-type __VLS_Props = {
-    modelValue?: HysTabValue;
-    defaultValue?: HysTabValue;
-    items: HysTabItem[];
-    disabled?: boolean;
-    type?: 'line' | 'card' | 'border-card' | 'segment';
-    vertical?: boolean;
-    placement?: 'top' | 'right' | 'bottom' | 'left';
-    size?: 'sm' | 'md' | 'lg';
-    stretch?: boolean;
-    centered?: boolean;
-    closable?: boolean;
-    addable?: boolean;
-    editable?: boolean;
-    trigger?: 'click' | 'hover';
-    activation?: 'auto' | 'manual';
-    /** 首次访问时才挂载面板；用于 panel 插槽。 */
-    lazy?: boolean;
-    /** 离开时销毁面板；默认保留已访问面板的局部状态。 */
-    destroyOnHide?: boolean;
-    animated?: boolean;
-    showScrollButtons?: boolean;
-    ariaLabel?: string;
-    beforeLeave?: (next: HysTabValue, current: HysTabValue) => boolean | void | Promise<boolean | void>;
-    beforeClose?: (value: HysTabValue) => boolean | void | Promise<boolean | void>;
-};
-declare function scrollToActiveTab(): void;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        prefix?: (props: {}) => any;
-    } & {
-        label?: (props: {
-            item: HysTabItem;
-            active: boolean;
-        }) => any;
-    } & {
-        'close-icon'?: (props: {
-            item: HysTabItem;
-        }) => any;
-    } & {
-        'add-icon'?: (props: {}) => any;
-    } & {
-        suffix?: (props: {}) => any;
-    } & {
-        panel?: (props: {
-            item: HysTabItem;
-            active: boolean;
-        }) => any;
-    } & {
-        default?: (props: {
-            active: HysTabValue;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    scrollToActiveTab: typeof scrollToActiveTab;
-    focus: (value?: HysTabValue) => void;
+import type { HysTabCloseScope, HysTabItem, HysTabsProps, HysTabsSlots, HysTabValue } from "./tabsTypes";
+export type { HysTabItem, HysTabValue } from "./tabsTypes";
+type __VLS_Slots = HysTabsSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysTabsProps, {
+    active: import("vue").ComputedRef<HysTabValue>;
+    recent: import("vue").ComputedRef<HysTabValue[]>;
+    closed: import("vue").ComputedRef<HysTabItem[]>;
+    select: (value: HysTabValue) => Promise<boolean>;
+    focus: (value?: HysTabValue) => void | undefined;
+    scrollToActiveTab: () => void | undefined;
+    add: (item?: HysTabItem) => Promise<boolean>;
+    close: (value?: HysTabValue) => Promise<boolean>;
+    closeMany: (scope: HysTabCloseScope | readonly HysTabValue[], anchor?: HysTabValue) => Promise<HysTabValue[]>;
+    rename: (value: HysTabValue, label: string) => Promise<boolean>;
+    move: (value: HysTabValue, target: HysTabValue, after?: boolean) => Promise<boolean>;
+    pin: (value: HysTabValue, pinned?: boolean) => Promise<boolean>;
+    favorite: (value: HysTabValue, favorite?: boolean) => Promise<boolean>;
+    restore: () => Promise<boolean>;
+    preload: (value: HysTabValue) => Promise<boolean>;
+    reload: (value?: HysTabValue) => Promise<boolean>;
+    save: () => boolean;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (value: HysTabValue) => any;
     "update:modelValue": (value: HysTabValue) => any;
     guardError: (error: unknown) => any;
     add: () => any;
     close: (value: HysTabValue) => any;
-    tabClick: (value: HysTabValue, event: MouseEvent) => any;
+    load: (value: HysTabValue, content: import("./tabsTypes").HysTabContent) => any;
+    loadError: (value: HysTabValue, error: unknown) => any;
+    selectionChange: (context: import("./tabsTypes").HysTabChangeContext) => any;
+    "update:items": (items: HysTabItem[]) => any;
     edit: (value: HysTabValue | undefined, action: "add" | "remove") => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    reorder: (context: import("./tabsTypes").HysTabOrderContext) => any;
+    rename: (value: HysTabValue, label: string) => any;
+    restore: (item: HysTabItem) => any;
+    tabClick: (value: HysTabValue, event: MouseEvent) => any;
+    tabDblclick: (value: HysTabValue, event: MouseEvent) => any;
+    tabContextmenu: (value: HysTabValue, event: KeyboardEvent | PointerEvent | MouseEvent) => any;
+    tabLongpress: (value: HysTabValue, event: PointerEvent) => any;
+    previewChange: (value: HysTabValue | undefined) => any;
+    closeBatch: (values: HysTabValue[]) => any;
+    pinChange: (value: HysTabValue, pinned: boolean) => any;
+    favoriteChange: (value: HysTabValue, favorite: boolean) => any;
+    loadStart: (value: HysTabValue) => any;
+    storageError: (error: unknown) => any;
+}, string, import("vue").PublicProps, Readonly<HysTabsProps> & Readonly<{
     onChange?: ((value: HysTabValue) => any) | undefined;
     "onUpdate:modelValue"?: ((value: HysTabValue) => any) | undefined;
     onGuardError?: ((error: unknown) => any) | undefined;
     onAdd?: (() => any) | undefined;
     onClose?: ((value: HysTabValue) => any) | undefined;
-    onTabClick?: ((value: HysTabValue, event: MouseEvent) => any) | undefined;
+    onLoad?: ((value: HysTabValue, content: import("./tabsTypes").HysTabContent) => any) | undefined;
+    onLoadError?: ((value: HysTabValue, error: unknown) => any) | undefined;
+    onSelectionChange?: ((context: import("./tabsTypes").HysTabChangeContext) => any) | undefined;
+    "onUpdate:items"?: ((items: HysTabItem[]) => any) | undefined;
     onEdit?: ((value: HysTabValue | undefined, action: "add" | "remove") => any) | undefined;
+    onReorder?: ((context: import("./tabsTypes").HysTabOrderContext) => any) | undefined;
+    onRename?: ((value: HysTabValue, label: string) => any) | undefined;
+    onRestore?: ((item: HysTabItem) => any) | undefined;
+    onTabClick?: ((value: HysTabValue, event: MouseEvent) => any) | undefined;
+    onTabDblclick?: ((value: HysTabValue, event: MouseEvent) => any) | undefined;
+    onTabContextmenu?: ((value: HysTabValue, event: KeyboardEvent | PointerEvent | MouseEvent) => any) | undefined;
+    onTabLongpress?: ((value: HysTabValue, event: PointerEvent) => any) | undefined;
+    onPreviewChange?: ((value: HysTabValue | undefined) => any) | undefined;
+    onCloseBatch?: ((values: HysTabValue[]) => any) | undefined;
+    onPinChange?: ((value: HysTabValue, pinned: boolean) => any) | undefined;
+    onFavoriteChange?: ((value: HysTabValue, favorite: boolean) => any) | undefined;
+    onLoadStart?: ((value: HysTabValue) => any) | undefined;
+    onStorageError?: ((error: unknown) => any) | undefined;
 }>, {
-    size: "sm" | "md" | "lg";
-    trigger: "click" | "hover";
+    disabled: boolean;
     lazy: boolean;
     destroyOnHide: boolean;
-    type: "line" | "card" | "segment" | "border-card";
+    fixed: boolean;
+    draggable: boolean;
+    closable: boolean;
+    vertical: boolean;
+    stretch: boolean;
+    sticky: boolean;
+    separator: boolean;
+    readonly: boolean;
+    animationName: string;
+    editable: boolean;
+    contextMenu: boolean;
+    preview: boolean;
+    responsive: boolean;
+    shortcuts: boolean;
+    centered: boolean;
+    preload: boolean | readonly HysTabValue[];
+    swipe: boolean;
     animated: boolean;
-    activation: "manual" | "auto";
+    workbench: boolean;
+    addable: boolean;
+    autoActivate: boolean;
     showScrollButtons: boolean;
+    dragScroll: boolean;
+    dragHandle: boolean;
+    titleTooltip: boolean;
+    moreSearch: boolean;
+    confirmDirty: boolean;
+    persistScroll: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/components/HysTabs/TabsMore/TabsMore.vue.d.ts

@@ -0,0 +1,14 @@
+import type { HysTabItem, HysTabsSlots, HysTabValue } from "../tabsTypes";
+type __VLS_Props = {
+    items: readonly HysTabItem[];
+    overflow: readonly HysTabValue[];
+    recent: readonly HysTabValue[];
+    active: HysTabValue;
+    disabled?: boolean;
+    search?: boolean;
+    slots: HysTabsSlots;
+    select: (value: HysTabValue) => Promise<boolean>;
+};
+declare const __VLS_export: 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>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/HysTabs/TabsPanels/TabsPanels.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HysTabItem, HysTabsSlots, HysTabValue } from "../tabsTypes";
+import type { TabDeclaration } from "../tabsItems";
+import type { useTabsPanels } from "../useTabsPanels";
+type __VLS_Props = {
+    items: readonly HysTabItem[];
+    declarations: readonly TabDeclaration[];
+    slots: HysTabsSlots;
+    active: HysTabValue;
+    panels: ReturnType<typeof useTabsPanels>;
+    panelId: (value: HysTabValue) => string;
+    tabId: (value: HysTabValue) => string;
+    declarative: boolean;
+    forcePanels: boolean;
+};
+declare const __VLS_export: 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>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/HysTabs/TabsPrompts/TabsPrompts.vue.d.ts

@@ -0,0 +1,7 @@
+import type { HysTabItem } from "../tabsTypes";
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    confirm: (items: HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+    rename: (item: HysTabItem) => Promise<string | boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/HysTabs/TabsSlot/TabsSlot.d.ts

@@ -0,0 +1,9 @@
+import { type VNodeChild } from "vue";
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    render: FunctionConstructor;
+    scope: ObjectConstructor;
+}>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    render: FunctionConstructor;
+    scope: ObjectConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/HysTabs/TabsWorkbench/TabsWorkbench.vue.d.ts

@@ -0,0 +1,32 @@
+import { type TabDeclaration } from "../tabsItems";
+import type { HysTabItem, HysTabSource, HysTabsProps, HysTabsSlots, HysTabValue, TabsEmit } from "../tabsTypes";
+type __VLS_Props = {
+    options: HysTabsProps;
+    declarations: TabDeclaration[];
+    declarative: boolean;
+    slots: HysTabsSlots;
+    emit: TabsEmit;
+};
+declare function focus(value?: HysTabValue): void;
+declare function closeFocused(value?: HysTabValue): Promise<boolean>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    active: import("vue").ComputedRef<HysTabValue>;
+    recent: import("vue").ShallowRef<HysTabValue[], HysTabValue[]>;
+    closed: import("vue").ComputedRef<HysTabItem[]>;
+    select: (value: HysTabValue, source?: HysTabSource) => Promise<boolean>;
+    focus: typeof focus;
+    scrollToActiveTab: (value?: HysTabValue) => void;
+    add: (item?: HysTabItem) => Promise<boolean>;
+    close: typeof closeFocused;
+    closeMany: (scope: import("../tabsTypes").HysTabCloseScope | readonly HysTabValue[], anchor?: HysTabValue) => Promise<HysTabValue[]>;
+    rename: (value: HysTabValue, name: string) => Promise<boolean>;
+    pin: (value: HysTabValue, pinned?: boolean) => Promise<boolean>;
+    favorite: (value: HysTabValue, favorite?: boolean) => Promise<boolean>;
+    move: (value: HysTabValue, target: HysTabValue, after?: boolean) => Promise<boolean>;
+    restore: () => Promise<boolean>;
+    preload: (value: HysTabValue) => Promise<boolean>;
+    reload: (value?: HysTabValue) => Promise<boolean>;
+    save: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/HysTabs/tabsConfig.d.ts

@@ -0,0 +1,4 @@
+import type { HysTabsConfig, HysTabsProps } from "./tabsTypes";
+export declare function configureHysTabs(config: HysTabsConfig): void;
+export declare function provideHysTabs(config: HysTabsConfig): void;
+export declare function useTabsOptions(props: HysTabsProps): import("vue").ComputedRef<HysTabsProps>;

package/dist/types/components/HysTabs/tabsItems.d.ts

@@ -0,0 +1,14 @@
+import { type VNodeChild } from "vue";
+import type { HysTabItem, HysTabPaneSlots, HysTabValue } from "./tabsTypes";
+export declare const tabToken: (key: HysTabValue) => string;
+export declare function tabIdToken(key: HysTabValue): string;
+export declare const usable: (item: HysTabItem) => boolean;
+export declare function orderedTabs(items: readonly HysTabItem[]): HysTabItem[];
+export declare function neighbor(items: readonly HysTabItem[], previous: readonly HysTabItem[], key: HysTabValue): HysTabItem | undefined;
+export declare function tabLength(value: string | number | undefined): string | undefined;
+export declare const bounded: (value: number | undefined, fallback: number, max: number) => number;
+export interface TabDeclaration {
+    item: HysTabItem;
+    slots: HysTabPaneSlots;
+}
+export declare function collectTabPanes(content: VNodeChild): TabDeclaration[];

package/dist/types/components/HysTabs/tabsPersistence.d.ts

@@ -0,0 +1,6 @@
+import type { useTabsState } from "./useTabsState";
+import type { HysTabsProps, TabsEmit } from "./tabsTypes";
+export declare function useTabsPersistence(props: () => HysTabsProps, state: ReturnType<typeof useTabsState>, nav: () => HTMLElement | undefined, emit: TabsEmit): {
+    save: () => boolean;
+    scrolled: () => void;
+};

package/dist/types/components/HysTabs/tabsTypes.d.ts

@@ -0,0 +1,236 @@
+import type { Component, CSSProperties, MaybeRefOrGetter, VNodeChild } from "vue";
+export type HysTabValue = string | number;
+export type HysTabPlacement = "top" | "right" | "bottom" | "left";
+export type HysTabType = "line" | "card" | "border-card" | "pill" | "segment" | "button" | "minimal" | "borderless";
+export type HysTabStatus = "loading" | "success" | "warning" | "error" | "info";
+export type HysTabSource = "click" | "hover" | "keyboard" | "wheel" | "swipe" | "menu" | "api" | "fallback" | "restore";
+export type HysTabAnimation = "fade" | "slide" | "scale" | "spring" | "none";
+export type HysTabCloseScope = "current" | "left" | "right" | "others" | "all";
+export type HysTabContent = string | Component | {
+    component: Component;
+    props?: Record<string, unknown>;
+} | null;
+export interface HysTabLoadContext {
+    item: HysTabItem;
+    signal: AbortSignal;
+}
+export interface HysTabItem {
+    label: string;
+    value: HysTabValue;
+    content?: string;
+    component?: Component;
+    componentProps?: Record<string, unknown>;
+    load?: (context: HysTabLoadContext) => HysTabContent | PromiseLike<HysTabContent>;
+    disabled?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    closable?: boolean;
+    movable?: boolean;
+    pinned?: boolean;
+    favorite?: boolean;
+    dirty?: boolean;
+    unread?: boolean;
+    badge?: number | string;
+    dot?: boolean;
+    status?: HysTabStatus;
+    icon?: Component;
+    statusIcon?: Component;
+    color?: string;
+    class?: string;
+    style?: CSSProperties;
+    width?: number | string;
+    lazy?: boolean;
+    cache?: boolean;
+    forceRender?: boolean;
+    preload?: boolean;
+}
+export interface HysTabGuardContext {
+    signal: AbortSignal;
+    source: HysTabSource;
+    item: HysTabItem;
+}
+export interface HysTabChangeContext {
+    value: HysTabValue;
+    previous: HysTabValue;
+    source: HysTabSource;
+}
+export interface HysTabOrderContext {
+    value: HysTabValue;
+    from: number;
+    to: number;
+    items: HysTabItem[];
+}
+export type HysTabSnapshot = Pick<HysTabItem, "value" | "label" | "pinned" | "favorite">;
+export interface HysTabsProps {
+    modelValue?: HysTabValue;
+    defaultValue?: HysTabValue;
+    items?: readonly HysTabItem[];
+    defaultItems?: readonly HysTabItem[];
+    workbench?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    type?: HysTabType;
+    vertical?: boolean;
+    placement?: HysTabPlacement;
+    responsive?: boolean;
+    breakpoint?: number;
+    size?: "sm" | "md" | "lg";
+    stretch?: boolean;
+    centered?: boolean;
+    align?: "start" | "center" | "end" | "between";
+    tabWidth?: number | string;
+    tabHeight?: number | string;
+    tabMaxWidth?: number | string;
+    gap?: number | string;
+    radius?: number | string;
+    separator?: boolean;
+    sticky?: boolean;
+    fixed?: boolean;
+    barOffset?: number | string;
+    panelHeight?: number | string;
+    panelMaxHeight?: number | string;
+    closable?: boolean;
+    addable?: boolean;
+    editable?: boolean;
+    autoActivate?: boolean;
+    trigger?: "click" | "hover";
+    hoverDelay?: number;
+    preview?: boolean;
+    activation?: "auto" | "manual";
+    lazy?: boolean;
+    preload?: boolean | readonly HysTabValue[];
+    destroyOnHide?: boolean;
+    cacheLimit?: number;
+    animated?: boolean;
+    animation?: HysTabAnimation;
+    animationName?: string;
+    duration?: number;
+    easing?: string;
+    overflow?: "scroll" | "wrap" | "menu" | "clip";
+    showScrollButtons?: boolean;
+    scrollAlign?: "nearest" | "center";
+    wheel?: "none" | "scroll" | "switch";
+    dragScroll?: boolean;
+    swipe?: boolean;
+    draggable?: boolean;
+    dragHandle?: boolean;
+    longPress?: number;
+    contextMenu?: boolean;
+    shortcuts?: boolean;
+    titleTooltip?: boolean;
+    moreSearch?: boolean;
+    confirmDirty?: boolean;
+    historyLimit?: number;
+    storageKey?: string;
+    storage?: "session" | "local";
+    persistScroll?: boolean;
+    restoreItem?: (snapshot: HysTabSnapshot) => HysTabItem | undefined;
+    createTab?: (items: readonly HysTabItem[]) => HysTabItem | undefined | PromiseLike<HysTabItem | undefined>;
+    ariaLabel?: string;
+    beforeLeave?: (next: HysTabValue, current: HysTabValue, context: HysTabGuardContext) => boolean | void | PromiseLike<boolean | void>;
+    beforeClose?: (value: HysTabValue, context: HysTabGuardContext) => boolean | void | PromiseLike<boolean | void>;
+    beforeReorder?: (context: HysTabOrderContext) => boolean | void;
+}
+export interface HysTabsEmits {
+    "update:modelValue": [value: HysTabValue];
+    "update:items": [items: HysTabItem[]];
+    change: [value: HysTabValue];
+    selectionChange: [context: HysTabChangeContext];
+    tabClick: [value: HysTabValue, event: MouseEvent];
+    tabDblclick: [value: HysTabValue, event: MouseEvent];
+    tabContextmenu: [
+        value: HysTabValue,
+        event: MouseEvent | KeyboardEvent | PointerEvent
+    ];
+    tabLongpress: [value: HysTabValue, event: PointerEvent];
+    previewChange: [value: HysTabValue | undefined];
+    close: [value: HysTabValue];
+    closeBatch: [values: HysTabValue[]];
+    add: [];
+    edit: [value: HysTabValue | undefined, action: "add" | "remove"];
+    reorder: [context: HysTabOrderContext];
+    restore: [item: HysTabItem];
+    rename: [value: HysTabValue, label: string];
+    pinChange: [value: HysTabValue, pinned: boolean];
+    favoriteChange: [value: HysTabValue, favorite: boolean];
+    loadStart: [value: HysTabValue];
+    load: [value: HysTabValue, content: HysTabContent];
+    loadError: [value: HysTabValue, error: unknown];
+    guardError: [error: unknown];
+    storageError: [error: unknown];
+}
+export type TabsEmit = <K extends keyof HysTabsEmits>(event: K, ...args: HysTabsEmits[K]) => void;
+export interface HysTabScope {
+    item: HysTabItem;
+    active: boolean;
+}
+export interface HysTabPanelScope extends HysTabScope {
+    loading: boolean;
+    error?: unknown;
+    content?: HysTabContent;
+    reload: () => Promise<boolean>;
+}
+export interface HysTabsMenuScope {
+    items: readonly HysTabItem[];
+    overflowed: readonly HysTabItem[];
+    active: HysTabValue;
+    select: (value: HysTabValue) => Promise<boolean>;
+    close: () => void;
+}
+export interface HysTabsContextScope {
+    item: HysTabItem;
+    run: (action: HysTabMenuAction) => void;
+    close: () => void;
+}
+export type HysTabMenuAction = HysTabCloseScope | "reload" | "pin" | "favorite" | "rename" | "restore";
+export interface HysTabsSlots {
+    default?: (scope: {
+        active: HysTabValue;
+    }) => VNodeChild;
+    panes?: () => VNodeChild;
+    label?: (scope: HysTabScope) => VNodeChild;
+    icon?: (scope: HysTabScope) => VNodeChild;
+    badge?: (scope: HysTabScope) => VNodeChild;
+    "status-icon"?: (scope: HysTabScope) => VNodeChild;
+    panel?: (scope: HysTabPanelScope) => VNodeChild;
+    loading?: (scope: HysTabPanelScope) => VNodeChild;
+    error?: (scope: HysTabPanelScope) => VNodeChild;
+    empty?: (scope: HysTabPanelScope) => VNodeChild;
+    preview?: (scope: HysTabScope) => VNodeChild;
+    prefix?: () => VNodeChild;
+    suffix?: () => VNodeChild;
+    "close-icon"?: (scope: HysTabScope) => VNodeChild;
+    "add-icon"?: () => VNodeChild;
+    "more-icon"?: () => VNodeChild;
+    more?: (scope: HysTabsMenuScope) => VNodeChild;
+    contextmenu?: (scope: HysTabsContextScope) => VNodeChild;
+}
+export type HysTabPaneProps = HysTabItem;
+export interface HysTabPaneSlots {
+    default?: (scope: HysTabPanelScope) => VNodeChild;
+    label?: (scope: HysTabScope) => VNodeChild;
+    icon?: (scope: HysTabScope) => VNodeChild;
+    badge?: (scope: HysTabScope) => VNodeChild;
+}
+export interface HysTabsInstance {
+    readonly active: HysTabValue;
+    readonly recent: readonly HysTabValue[];
+    readonly closed: readonly HysTabSnapshot[];
+    select: (value: HysTabValue) => Promise<boolean>;
+    focus: (value?: HysTabValue) => void;
+    scrollToActiveTab: () => void;
+    add: (item?: HysTabItem) => Promise<boolean>;
+    close: (value?: HysTabValue) => Promise<boolean>;
+    closeMany: (scope: HysTabCloseScope | readonly HysTabValue[], anchor?: HysTabValue) => Promise<HysTabValue[]>;
+    rename: (value: HysTabValue, label: string) => Promise<boolean>;
+    move: (value: HysTabValue, target: HysTabValue, after?: boolean) => Promise<boolean>;
+    pin: (value: HysTabValue, pinned?: boolean) => Promise<boolean>;
+    favorite: (value: HysTabValue, favorite?: boolean) => Promise<boolean>;
+    restore: () => Promise<boolean>;
+    preload: (value: HysTabValue) => Promise<boolean>;
+    reload: (value?: HysTabValue) => Promise<boolean>;
+    save: () => boolean;
+}
+export interface HysTabsConfig {
+    defaults?: MaybeRefOrGetter<Partial<HysTabsProps>>;
+}

package/dist/types/components/HysTabs/useHysRouteTabs.d.ts

@@ -0,0 +1,22 @@
+import { type MaybeRefOrGetter } from "vue";
+import type { HysTabGuardContext, HysTabItem, HysTabValue } from "./tabsTypes";
+export interface HysRouteTabItem extends HysTabItem {
+    to?: string;
+}
+export interface HysRouteTabsOptions<R> {
+    route: MaybeRefOrGetter<R>;
+    resolve: (route: R) => HysRouteTabItem | undefined;
+    navigate: (item: HysRouteTabItem, signal: AbortSignal) => unknown;
+    allow?: (item: HysRouteTabItem, route: R) => boolean;
+    fallback?: () => HysRouteTabItem | undefined;
+    onError?: (error: unknown) => void;
+    historyLimit?: number;
+}
+export declare function useHysRouteTabs<R>(options: HysRouteTabsOptions<R>): {
+    items: import("vue").ShallowRef<HysRouteTabItem[], HysRouteTabItem[]>;
+    active: import("vue").Ref<HysTabValue | undefined, HysTabValue | undefined>;
+    history: import("vue").ShallowRef<HysTabValue[], HysTabValue[]>;
+    setItems: (next: readonly HysRouteTabItem[]) => void;
+    select: (key: HysTabValue) => Promise<boolean>;
+    beforeClose: (key: HysTabValue, context?: HysTabGuardContext) => Promise<boolean>;
+};