hys-ui 0.2.0 → 0.3.0

package/dist/types/components/HysContextMenu/HysMenuPanel.vue.d.ts

@@ -0,0 +1,79 @@
+import { type MenuRow, type HysMenuItemContext } from "../../composables/menu";
+declare const __VLS_export: <N extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        rows: readonly MenuRow<N>[];
+        level: number;
+        id: string;
+        rootId: string;
+        label: string;
+        parentLabel?: string;
+        busy: boolean;
+        loading: boolean;
+        emptyText: string;
+        loadingText: string;
+        backText: string;
+        direction?: "ltr" | "rtl";
+        context: (row: MenuRow<N>) => HysMenuItemContext<N>;
+        tabbable: (row: MenuRow<N>) => number;
+    } & {
+        onScroll?: (() => any) | undefined;
+        onChoose?: ((row: MenuRow<N>, event: MouseEvent) => any) | undefined;
+        onFocusRow?: ((row: MenuRow<N>) => any) | undefined;
+        onHoverRow?: ((row: MenuRow<N>) => any) | undefined;
+        onKeyboard?: ((event: KeyboardEvent) => any) | undefined;
+        onBack?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {}) => any;
+    } & {
+        loading?: (props: {}) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        icon?: (props: {
+            item: N;
+            value: import("../..").HysMenuKey | undefined;
+            label: string;
+            path: readonly N[];
+            keys: readonly import("../..").HysMenuKey[];
+            level: number;
+            disabled: boolean;
+            checked: boolean;
+            selected: boolean;
+            expanded: boolean;
+            submenu: boolean;
+        }) => any;
+    } & {
+        item?: (props: {
+            item: N;
+            value: import("../..").HysMenuKey | undefined;
+            label: string;
+            path: readonly N[];
+            keys: readonly import("../..").HysMenuKey[];
+            level: number;
+            disabled: boolean;
+            checked: boolean;
+            selected: boolean;
+            expanded: boolean;
+            submenu: boolean;
+        }) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+    emit: ((evt: "scroll") => void) & ((evt: "choose", row: MenuRow<N>, event: MouseEvent) => void) & ((evt: "focusRow", row: MenuRow<N>) => void) & ((evt: "hoverRow", row: MenuRow<N>) => void) & ((evt: "keyboard", event: KeyboardEvent) => void) & ((evt: "back") => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/HysContextMenu/HysMenuSlot.d.ts

@@ -0,0 +1,8 @@
+import { type FunctionalComponent, type VNodeChild } from "vue";
+/** Keep a single interactive root so router/link slots receive menu semantics. */
+declare const HysMenuSlot: FunctionalComponent<{
+    content?: (scope: any) => VNodeChild;
+    scope: any;
+    nodeAttrs?: Record<string, unknown>;
+}>;
+export default HysMenuSlot;

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

@@ -1,125 +1,72 @@
-export interface GridColumn {
-    key: string;
-    label: string;
-    width?: number;
-    minWidth?: number;
-    maxWidth?: number;
-    sortable?: boolean;
-    filterable?: boolean;
-    hideable?: boolean;
-    resizable?: boolean;
-    reorderable?: boolean;
-    pinned?: 'left' | 'right';
-    align?: 'left' | 'center' | 'right';
-    summary?: 'sum' | 'avg' | 'min' | 'max' | 'count';
-    editable?: boolean;
-}
-type Row = Record<string, unknown>;
-type Sort = {
-    key: string;
-    direction: 'asc' | 'desc';
-} | null;
-type SortRule = {
-    key: string;
-    direction: 'asc' | 'desc';
-};
-type __VLS_Props = {
-    columns: GridColumn[];
-    rows: Row[];
-    rowKey?: string;
-    pageSize?: number;
-    storageKey?: string;
-    selectable?: boolean;
-    loading?: boolean;
-    emptyText?: string;
-    density?: 'compact' | 'normal' | 'comfortable';
-    serverMode?: boolean;
-    totalRows?: number;
-    page?: number;
-    multiSort?: boolean;
-    stickyHeader?: boolean;
-    groupable?: boolean;
-    showSummary?: boolean;
-    treeMode?: boolean;
-    parentKey?: string;
-    editable?: boolean;
-};
-declare function resetColumns(): void;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        [x: string]: ((props: {
-            row: Row;
-            value: unknown;
+import { type HysDataGridKey, type HysDataGridProps, type HysDataGridQuery, type HysDataGridSort } from "../../composables/dataGrid";
+export type { GridColumn } from "../../composables/dataGrid";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<HysDataGridProps<T> & {
+        onLoadError?: ((error: unknown) => any) | undefined;
+        onSelectionChange?: ((keys: HysDataGridKey[]) => any) | undefined;
+        onPageSizeChange?: ((size: number) => any) | undefined;
+        onRowClick?: ((row: T) => any) | undefined;
+        "onUpdate:selectedRowKeys"?: ((keys: HysDataGridKey[]) => any) | undefined;
+        onColumnsChange?: ((keys: string[]) => any) | undefined;
+        onSortChange?: ((sort: HysDataGridSort | null) => any) | undefined;
+        onPageChange?: ((page: number) => any) | undefined;
+        "onUpdate:query"?: ((query: HysDataGridQuery) => any) | undefined;
+        onQueryChange?: ((query: HysDataGridQuery) => any) | undefined;
+        onCellEdit?: ((payload: {
+            row: T;
+            rowKey: HysDataGridKey;
+            column: string;
+            value: string;
         }) => any) | undefined;
+        onBatchEdit?: ((payload: {
+            keys: HysDataGridKey[];
+            column: string;
+            value: string;
+        }) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        resetColumns: () => void;
+        getQuery: () => HysDataGridQuery;
+        setQuery: (change: Partial<HysDataGridQuery>) => void;
+        resetQuery: () => void;
+        reload: () => void;
+        getSelection: () => HysDataGridKey[];
+        clearSelection: () => void;
+        toggleRowSelection: (key: HysDataGridKey, checked?: boolean) => void;
+        scrollTo: (options: ScrollToOptions) => void;
+        scrollToRow: (key: HysDataGridKey) => boolean;
+    }>) => void;
+    attrs: any;
+    slots: {
+        [key: string]: ((scope: any) => unknown) | undefined;
+        empty?(scope: {
+            query: HysDataGridQuery;
+        }): unknown;
+        loading?(): unknown;
+        error?(scope: {
+            error: unknown;
+            retry: () => void;
+        }): unknown;
     };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    resetColumns: typeof resetColumns;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    pageSizeChange: (size: number) => any;
-    rowClick: (row: Row) => any;
-    selectionChange: (keys: (string | number)[]) => any;
-    columnsChange: (keys: string[]) => any;
-    sortChange: (sort: Sort) => any;
-    pageChange: (page: number) => any;
-    queryChange: (query: {
-        page: number;
-        pageSize: number;
-        sort: SortRule[];
-        search: string;
-        filters: Record<string, string>;
-    }) => any;
-    cellEdit: (payload: {
-        row: Row;
-        rowKey: string | number;
+    emit: ((evt: "loadError", error: unknown) => void) & ((evt: "selectionChange", keys: HysDataGridKey[]) => void) & ((evt: "pageSizeChange", size: number) => void) & ((evt: "rowClick", row: T) => void) & ((evt: "update:selectedRowKeys", keys: HysDataGridKey[]) => void) & ((evt: "columnsChange", keys: string[]) => void) & ((evt: "sortChange", sort: HysDataGridSort | null) => void) & ((evt: "pageChange", page: number) => void) & ((evt: "update:query", query: HysDataGridQuery) => void) & ((evt: "queryChange", query: HysDataGridQuery) => void) & ((evt: "cellEdit", payload: {
+        row: T;
+        rowKey: HysDataGridKey;
         column: string;
         value: string;
-    }) => any;
-    batchEdit: (payload: {
-        keys: (string | number)[];
+    }) => void) & ((evt: "batchEdit", payload: {
+        keys: HysDataGridKey[];
         column: string;
         value: string;
-    }) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onPageSizeChange?: ((size: number) => any) | undefined;
-    onRowClick?: ((row: Row) => any) | undefined;
-    onSelectionChange?: ((keys: (string | number)[]) => any) | undefined;
-    onColumnsChange?: ((keys: string[]) => any) | undefined;
-    onSortChange?: ((sort: Sort) => any) | undefined;
-    onPageChange?: ((page: number) => any) | undefined;
-    onQueryChange?: ((query: {
-        page: number;
-        pageSize: number;
-        sort: SortRule[];
-        search: string;
-        filters: Record<string, string>;
-    }) => any) | undefined;
-    onCellEdit?: ((payload: {
-        row: Row;
-        rowKey: string | number;
-        column: string;
-        value: string;
-    }) => any) | undefined;
-    onBatchEdit?: ((payload: {
-        keys: (string | number)[];
-        column: string;
-        value: string;
-    }) => any) | undefined;
-}>, {
-    loading: boolean;
-    emptyText: string;
-    selectable: boolean;
-    pageSize: number;
-    rowKey: string;
-    density: "normal" | "compact" | "comfortable";
-    parentKey: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
+    }) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/HysDatePicker/HysDatePickerControl.vue.d.ts

@@ -59,7 +59,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     onOk?: ((...args: any[]) => any) | undefined;
 }>, {
     bordered: boolean;
-    type: import("../../index.js").HysDatePickerType;
+    type: import("../..").HysDatePickerType;
     clearable: boolean;
     open: boolean;
     appendTo: string | false | HTMLElement;

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

@@ -1,46 +1,103 @@
-type __VLS_Props = {
-    open: boolean;
-    title: string;
-    width?: string;
-    height?: string;
-    closeOnMask?: boolean;
-    closeOnEscape?: boolean;
-    showClose?: boolean;
-    destroyOnClose?: boolean;
-    fullscreen?: boolean;
-    placement?: 'left' | 'right' | 'top' | 'bottom';
-    beforeClose?: (reason: 'mask' | 'escape' | 'button') => boolean | void | Promise<boolean | void>;
-};
-declare function requestClose(reason?: 'mask' | 'escape' | 'button'): Promise<void>;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        header?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    } & {
-        footer?: (props: {
-            close: typeof requestClose;
-            closing: boolean;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    close: typeof requestClose;
+import { type HysDrawerProps, type HysDrawerSlots, type HysDrawerResizeInfo } from "../../composables/drawer";
+type __VLS_Slots = HysDrawerSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysDrawerProps, {
     element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    body: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    open: import("vue").Ref<boolean, boolean>;
+    closing: import("vue").ComputedRef<boolean>;
+    confirming: import("vue").ComputedRef<boolean>;
+    fullscreen: import("vue").ComputedRef<boolean>;
+    resizing: import("vue").Ref<boolean, boolean>;
+    size: import("vue").ComputedRef<number>;
+    pushed: import("vue").ComputedRef<boolean>;
+    focus: () => void;
+    show: () => Promise<boolean>;
+    close: (reasonOrEvent?: import("../../index.js").HysModalCloseReason | Event, event?: Event) => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    confirm: (event?: Event) => Promise<boolean>;
+    setFullscreen: (value: boolean) => Promise<boolean>;
+    toggleFullscreen: () => Promise<boolean>;
+    resizeTo: (value: number | string) => Promise<boolean>;
+    resetSize: () => Promise<boolean>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
     close: () => any;
-    closeError: (error: unknown) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    closeError: (error: unknown, context: import("../../index.js").HysModalActionContext) => any;
+    afterClose: () => any;
+    visibleChange: (value: boolean) => any;
+    cancel: (context: import("../../index.js").HysModalActionContext) => any;
+    resize: (size: number) => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+    opened: () => any;
+    closed: () => any;
+    ok: (context: import("../../index.js").HysModalActionContext) => any;
+    resizeEnd: (size: number, info: HysDrawerResizeInfo) => any;
+    resizeStart: (size: number) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+    confirmError: (error: unknown, context: import("../../index.js").HysModalActionContext) => any;
+    "update:fullscreen": (value: boolean) => any;
+    fullscreenChange: (value: boolean) => any;
+    "update:resizeValue": (value: number | null) => any;
+    afterOpenChange: (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysDrawerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     onClose?: (() => any) | undefined;
-    onCloseError?: ((error: unknown) => any) | undefined;
+    onCloseError?: ((error: unknown, context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onAfterClose?: (() => any) | undefined;
+    onVisibleChange?: ((value: boolean) => any) | undefined;
+    onCancel?: ((context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onResize?: ((size: number) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOk?: ((context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onResizeEnd?: ((size: number, info: HysDrawerResizeInfo) => any) | undefined;
+    onResizeStart?: ((size: number) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onConfirmError?: ((error: unknown, context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    "onUpdate:fullscreen"?: ((value: boolean) => any) | undefined;
+    onFullscreenChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:resizeValue"?: ((value: number | null) => any) | undefined;
+    onAfterOpenChange?: ((value: boolean) => any) | undefined;
 }>, {
-    width: string;
-    placement: "left" | "right" | "top" | "bottom";
-    closeOnMask: boolean;
+    modelValue: boolean;
+    size: number | (string & {}) | import("../../index.js").HysDrawerSizeName;
+    footer: boolean;
+    title: string;
+    autofocus: boolean;
+    transition: false | "fade" | "slide" | "none" | "slide-fade";
+    closeText: string;
+    transitionDuration: number;
+    placement: import("../../index.js").HysDrawerPlacement;
+    open: boolean;
+    appendTo: string | false | HTMLElement;
+    loadingText: string;
+    fullscreen: boolean;
     closeOnEscape: boolean;
+    cancelText: string;
+    closeOnMask: boolean;
     showClose: boolean;
     destroyOnClose: boolean;
+    modal: boolean;
+    lockScroll: boolean;
+    trapFocus: boolean;
+    restoreFocus: boolean;
+    headerSize: import("../../index.js").HysModalSectionSize;
+    footerSize: import("../../index.js").HysModalSectionSize;
+    headerAriaLevel: number;
+    fullscreenText: string;
+    restoreText: string;
+    showCancel: boolean;
+    okText: string;
+    showError: boolean;
+    closeOnConfirm: boolean;
+    withHeader: boolean;
+    resetSizeOnClose: 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/HysEmpty/HysEmpty.vue.d.ts

@@ -1,23 +1,27 @@
-type __VLS_Props = {
-    title?: string;
-    description?: string;
-    image?: string;
-    imageSize?: number;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        image?: (props: {}) => any;
-    } & {
-        description?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    title: string;
-    description: string;
-    imageSize: number;
+import { type HysEmptyProps, type HysEmptySlots } from "../../composables/feedback";
+type __VLS_Slots = HysEmptySlots;
+declare function retryImage(): boolean;
+declare const __VLS_base: import("vue").DefineComponent<HysEmptyProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    imageElement: import("vue").Ref<HTMLImageElement | undefined, HTMLImageElement | undefined>;
+    loadingImage: import("vue").Ref<boolean, boolean>;
+    failedImage: import("vue").Ref<boolean, boolean>;
+    retryImage: typeof retryImage;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    imageLoad: (event: Event) => any;
+    imageError: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<HysEmptyProps> & Readonly<{
+    onImageLoad?: ((event: Event) => any) | undefined;
+    onImageError?: ((event: Event) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    title: string | false;
+    image: string | false;
+    description: string | false;
+    imageFit: "fill" | "none" | "contain" | "cover" | "scale-down";
+    imageLoading: "lazy" | "eager";
+    illustration: import("../..").HysEmptyIllustration;
+    showImageLoading: 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/HysFileManager/HysFileManager.vue.d.ts

@@ -13,14 +13,14 @@ type __VLS_ModelProps = {
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: ManagedFile[]) => any;
-    download: (id: string) => any;
     remove: (id: string) => any;
     upload: (files: File[]) => any;
+    download: (id: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: ManagedFile[]) => any) | undefined;
-    onDownload?: ((id: string) => any) | undefined;
     onRemove?: ((id: string) => any) | undefined;
     onUpload?: ((files: File[]) => any) | undefined;
+    onDownload?: ((id: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,3 +1,4 @@
+import type { HysPopupMotionProps } from '../../motion/popup';
 import type { HysGanttScrollOptions, HysGanttDependencyChange, HysGanttDependencyInvalid, HysGanttDependencyMove, HysGanttHistoryEntry, HysGanttHistoryState, HysGanttHistoryInvalid, HysGanttConflict } from "../../composables/gantt";
 export interface GanttItem {
     id: string | number;
@@ -12,7 +13,7 @@ export interface GanttItem {
     disabled?: boolean;
 }
 type Scale = "day" | "week" | "month";
-type __VLS_Props = {
+type __VLS_Props = HysPopupMotionProps & {
     items: GanttItem[];
     modelValue?: string | number | null;
     scale?: Scale;

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

@@ -1,4 +1,5 @@
-type __VLS_Props = {
+import type { HysPopupMotionProps } from '../../motion/popup';
+type __VLS_Props = HysPopupMotionProps & {
     users: {
         id: string;
         name: string;