hys-ui 0.2.0 → 0.3.0

package/dist/types/composables/useTagInput.d.ts

@@ -0,0 +1,66 @@
+import { type Ref } from "vue";
+import { type HysTagInputProps, type HysTagInputReason } from "./tagInput";
+export declare function useTagInput(props: HysTagInputProps, emit: (event: string, ...args: any[]) => void): {
+    attrs: import("vue").Attrs;
+    field: import("./formContext").HysFieldContext | undefined;
+    control: {
+        disabled: import("vue").ComputedRef<boolean>;
+        size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+        label: import("vue").ComputedRef<string | undefined>;
+    };
+    element: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    errorId: string;
+    draft: Ref<string, string>;
+    pending: Ref<boolean, boolean>;
+    composing: Ref<boolean, boolean>;
+    focused: Ref<boolean, boolean>;
+    values: import("vue").ComputedRef<string[]>;
+    status: import("vue").ComputedRef<import("./formContext").HysFormStatus | undefined>;
+    maximum: import("vue").ComputedRef<number>;
+    context: import("vue").ComputedRef<{
+        values: string[];
+        draft: string;
+        disabled: boolean;
+        readonly: boolean;
+        pending: boolean;
+        add: (value?: string | string[]) => Promise<boolean>;
+        clear: () => Promise<boolean>;
+    }>;
+    tags: import("vue").ComputedRef<{
+        value: string;
+        index: number;
+        key: string;
+    }[]>;
+    drag: Ref<{
+        index: number;
+        values: string[];
+    } | undefined, {
+        index: number;
+        values: string[];
+    } | undefined>;
+    drop: Ref<{
+        index: number;
+        after: boolean;
+    } | undefined, {
+        index: number;
+        after: boolean;
+    } | undefined>;
+    add: (value?: string | string[], reason?: HysTagInputReason) => Promise<boolean>;
+    remove: (index: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    move: (from: number, to: number) => Promise<boolean>;
+    focus: (options?: FocusOptions) => void;
+    nativeInput: (event: Event) => void;
+    compositionEnd: (event: CompositionEvent) => void;
+    pasted: (event: ClipboardEvent) => void;
+    key: (event: KeyboardEvent) => void;
+    tagKey: (event: KeyboardEvent, index: number) => Promise<void>;
+    focusIn: (event: FocusEvent) => void;
+    focusOut: (event: FocusEvent, extra?: HTMLElement) => void;
+    stopDrag: () => void;
+    dragStart: (event: DragEvent, index: number) => void;
+    dragOver: (event: DragEvent, index: number) => void;
+    dragDrop: (event: DragEvent) => Promise<void>;
+    setDraft: (value: string) => void;
+};

package/dist/types/composables/useTransferMotion.d.ts

@@ -0,0 +1,36 @@
+import { type Ref } from "vue";
+import { type HysTransferKey, type HysTransferSide } from "./transfer";
+interface Options {
+    animated?: boolean;
+    moveAnimation?: "flight" | "fade" | "none";
+    moveDuration?: number;
+    maxAnimatedItems?: number;
+    highlightOnArrival?: boolean;
+}
+type Box = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    right: number;
+    bottom: number;
+};
+interface Sample {
+    token: string;
+    label: string;
+    box: Box;
+}
+interface Snapshot {
+    generation: number;
+    direction: HysTransferSide;
+    count: number;
+    samples: Sample[];
+}
+/** Bounded visual feedback after an accepted move; never measures every data row. */
+export declare function useTransferMotion(root: Ref<HTMLElement | undefined>, options: Options): {
+    capture: (direction: HysTransferSide, keys: readonly HysTransferKey[]) => Snapshot | undefined;
+    play: (snapshot: Snapshot | undefined) => void;
+    stop: () => void;
+    cancelPlaying: () => void;
+};
+export {};

package/dist/types/composables/useUpload.d.ts

@@ -0,0 +1,94 @@
+import { type Ref } from "vue";
+import { type HysUploadProps, type HysUploadItem, type HysUploadFileContext, type HysUploadSlotContext, type HysUploadStatus } from "./upload";
+export declare function useUpload<T extends HysUploadItem>(props: HysUploadProps<T>, emit: (name: string, ...args: any[]) => void): {
+    element: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    zone: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    active: Ref<boolean, boolean>;
+    available: import("vue").ComputedRef<boolean>;
+    disabled: import("vue").ComputedRef<boolean>;
+    size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+    label: import("vue").ComputedRef<string | undefined>;
+    field: import("./formContext").HysFieldContext | undefined;
+    checking: Ref<boolean, boolean>;
+    dragging: Ref<boolean, boolean>;
+    lastError: Ref<string, string>;
+    words: import("vue").ComputedRef<{
+        choose: string;
+        drag: string;
+        checking: string;
+        localHint: string;
+        uploadHint: string;
+        files: string;
+        ready: string;
+        uploading: string;
+        success: string;
+        error: string;
+        queued: string;
+        removing: string;
+        submit: string;
+        abort: string;
+        retry: string;
+        clear: string;
+        remove: string;
+        preview: string;
+        download: string;
+        empty: string;
+    }>;
+    files: import("vue").ComputedRef<T[]>;
+    requests: {
+        configured: import("vue").ComputedRef<boolean>;
+        queue: import("vue").ShallowRef<string[], string[]>;
+        tasks: import("vue").ShallowRef<Map<string, {
+            uid: string;
+            raw: File;
+            controller: AbortController;
+            phase: "preparing" | "running" | "finishing";
+            stop?: (() => void) | undefined;
+            percentage: number;
+        }>, Map<string, {
+            uid: string;
+            raw: File;
+            controller: AbortController;
+            phase: "preparing" | "running" | "finishing";
+            stop?: (() => void) | undefined;
+            percentage: number;
+        }>>;
+        uploading: import("vue").ComputedRef<number>;
+        queued: import("vue").ComputedRef<number>;
+        activeKeys: import("vue").ComputedRef<Set<string>>;
+        queuedKeys: import("vue").ComputedRef<Set<string>>;
+        submit: (uid?: string) => Promise<number>;
+        retry: (uid: string) => Promise<boolean>;
+        abort: (uid?: string, reason?: string, reset?: boolean) => number;
+        cleanup: () => void;
+    };
+    removing: import("vue").ShallowRef<Set<string>, Set<string>>;
+    preview: import("vue").ShallowRef<{
+        file: T;
+        url: string;
+    } | undefined, {
+        file: T;
+        url: string;
+    } | undefined>;
+    closePreview: () => void;
+    context: (file: T) => HysUploadFileContext<T>;
+    scope: import("vue").ComputedRef<HysUploadSlotContext<T>>;
+    canPreview: (file: T) => boolean;
+    canDownload: (file: T) => boolean;
+    open: (event?: Event) => void;
+    click: (event: MouseEvent) => void;
+    keys: (event: KeyboardEvent) => void;
+    drop: (event: DragEvent) => void;
+    dragEnter: (event: DragEvent) => void;
+    dragOver: (event: DragEvent) => void;
+    dragLeave: () => void;
+    paste: (event: ClipboardEvent) => void;
+    blur: (event: FocusEvent) => void;
+    addFiles: (inputFiles: readonly File[]) => Promise<T[]>;
+    remove: (file: T | string) => Promise<boolean>;
+    clearFiles: (statuses?: readonly HysUploadStatus[]) => Promise<boolean>;
+    previewFile: (file: T | string) => Promise<boolean>;
+    download: (file: T | string) => Promise<boolean>;
+    focus: () => void;
+};

package/dist/types/composables/useUploadModel.d.ts

@@ -0,0 +1,14 @@
+import type { HysUploadProps, HysUploadItem, HysUploadChangeType } from "./upload";
+export declare function useUploadModel<T extends HysUploadItem>(props: HysUploadProps<T>, emit: (name: string, ...args: any[]) => void, live: () => boolean): {
+    files: import("vue").ComputedRef<T[]>;
+    controlled: import("vue").ComputedRef<boolean>;
+    commit: (change: (current: readonly T[]) => T[] | undefined, type: HysUploadChangeType, options?: {
+        force?: boolean;
+        allowInactive?: boolean;
+        guard?: () => boolean;
+        accepted?: () => void;
+    }) => Promise<boolean>;
+    cancel: () => void;
+    resetLocal: () => void;
+    interrupt: (keys: ReadonlySet<string>) => void;
+};

package/dist/types/composables/useUploadRequests.d.ts

@@ -0,0 +1,38 @@
+import { type Ref } from "vue";
+import { type HysUploadItem, type HysUploadProps, type HysUploadChangeType } from "./upload";
+export declare function useUploadRequests<T extends HysUploadItem>(options: {
+    props: HysUploadProps<T>;
+    files: Readonly<Ref<readonly T[]>>;
+    available: Readonly<Ref<boolean>>;
+    live: () => boolean;
+    emit: (name: string, ...args: any[]) => void;
+    prepare: (file: T, signal: AbortSignal) => Promise<Blob | undefined>;
+    forget: (uid: string) => void;
+    patch: (changes: Map<string, Partial<T>>, type: HysUploadChangeType, guard?: (uid?: string) => boolean) => Promise<boolean>;
+}): {
+    configured: import("vue").ComputedRef<boolean>;
+    queue: import("vue").ShallowRef<string[], string[]>;
+    tasks: import("vue").ShallowRef<Map<string, {
+        uid: string;
+        raw: File;
+        controller: AbortController;
+        phase: "preparing" | "running" | "finishing";
+        stop?: () => void;
+        percentage: number;
+    }>, Map<string, {
+        uid: string;
+        raw: File;
+        controller: AbortController;
+        phase: "preparing" | "running" | "finishing";
+        stop?: () => void;
+        percentage: number;
+    }>>;
+    uploading: import("vue").ComputedRef<number>;
+    queued: import("vue").ComputedRef<number>;
+    activeKeys: import("vue").ComputedRef<Set<string>>;
+    queuedKeys: import("vue").ComputedRef<Set<string>>;
+    submit: (uid?: string) => Promise<number>;
+    retry: (uid: string) => Promise<boolean>;
+    abort: (uid?: string, reason?: string, reset?: boolean) => number;
+    cleanup: () => void;
+};

package/dist/types/composables/useVirtualTableLayout.d.ts

@@ -0,0 +1,51 @@
+import { type CSSProperties } from "vue";
+import { type HysVirtualTableAlign, type HysVirtualTableColumn, type HysVirtualTableProps, type HysVirtualTableRange, type HysVirtualTableScroll } from "./virtualTable";
+export interface VirtualColumn<T extends object> {
+    token: string;
+    column?: HysVirtualTableColumn<T>;
+    index: number;
+    width: number;
+    offset: number;
+    left?: number;
+    right?: number;
+    selection?: boolean;
+    gap?: boolean;
+}
+export declare function useVirtualTableLayout<T extends object>(props: HysVirtualTableProps<T>, count: () => number, lastKey: () => string | undefined, report: {
+    scroll: (state: HysVirtualTableScroll) => void;
+    range: (state: HysVirtualTableRange) => void;
+    end: (state: {
+        distance: number;
+        total: number;
+    }) => void;
+}): {
+    viewport: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    live: import("vue").Ref<boolean, boolean>;
+    rowHeight: import("vue").ComputedRef<number>;
+    headerHeight: import("vue").ComputedRef<number>;
+    topHeight: import("vue").ComputedRef<number>;
+    bodyHeight: import("vue").ComputedRef<number>;
+    rootStyle: import("vue").ComputedRef<{
+        width: string | undefined;
+    }>;
+    viewportStyle: import("vue").ComputedRef<{
+        height: string;
+    }>;
+    columns: import("vue").ComputedRef<VirtualColumn<T>[]>;
+    columnMap: import("vue").ComputedRef<Map<string, VirtualColumn<T>>>;
+    renderColumns: import("vue").ComputedRef<VirtualColumn<T>[]>;
+    contentWidth: import("vue").ComputedRef<number>;
+    scrollTop: import("vue").Ref<number, number>;
+    scrollLeft: import("vue").Ref<number, number>;
+    range: import("vue").ComputedRef<HysVirtualTableRange>;
+    scrollTo: (options: {
+        top?: number;
+        left?: number;
+        behavior?: ScrollBehavior;
+    }) => void;
+    scrollToRow: (index: number, align?: HysVirtualTableAlign) => void;
+    scrollToColumn: (key: string, align?: HysVirtualTableAlign) => boolean;
+    onScroll: () => void;
+    remeasure: () => void;
+};
+export declare function virtualColumnStyle<T extends object>(cell: VirtualColumn<T>): CSSProperties;

package/dist/types/composables/virtualTable.d.ts

@@ -0,0 +1,126 @@
+import type { CSSProperties, HTMLAttributes, VNodeChild } from "vue";
+export type HysVirtualTableKey = string | number;
+export type HysVirtualTableAlign = "start" | "center" | "end" | "nearest";
+export interface HysVirtualTableSort {
+    key: string;
+    direction: "asc" | "desc";
+}
+export interface HysVirtualTableCell<T extends object = Record<string, unknown>> {
+    row: T;
+    column: HysVirtualTableColumn<T>;
+    value: unknown;
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface HysVirtualTableColumn<T extends object = any> {
+    key: string;
+    label: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    dataIndex?: string | readonly (string | number)[];
+    valueGetter?: (row: T, index: number) => unknown;
+    formatter?: (context: HysVirtualTableCell<T>) => VNodeChild;
+    fixed?: boolean | "left" | "right";
+    hidden?: boolean;
+    align?: "left" | "center" | "right";
+    headerAlign?: "left" | "center" | "right";
+    sortable?: boolean | "custom";
+    sorter?: (a: T, b: T) => number;
+    className?: string;
+    headerClassName?: string;
+}
+export interface HysVirtualTableRange {
+    start: number;
+    end: number;
+    visibleStart: number;
+    visibleEnd: number;
+    columnKeys: string[];
+}
+export interface HysVirtualTableScroll {
+    scrollTop: number;
+    scrollLeft: number;
+    direction: "up" | "down" | "left" | "right" | null;
+}
+export interface HysVirtualTableProps<T extends object> {
+    rows: readonly T[];
+    columns: readonly HysVirtualTableColumn<T>[];
+    rowKey?: string | ((row: T, index: number) => HysVirtualTableKey);
+    rowHeight?: number;
+    height?: number | string;
+    width?: number | string;
+    headerHeight?: number;
+    showHeader?: boolean;
+    fit?: boolean;
+    overscan?: number;
+    virtualColumns?: boolean;
+    columnOverscan?: number;
+    loading?: boolean;
+    loadingMode?: "replace" | "overlay";
+    loadingText?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    fixedRows?: readonly T[];
+    striped?: boolean;
+    bordered?: boolean;
+    sortState?: HysVirtualTableSort | null;
+    defaultSort?: HysVirtualTableSort | null;
+    selectable?: boolean | ((row: T, index: number) => boolean);
+    selectedRowKeys?: readonly HysVirtualTableKey[];
+    defaultSelectedRowKeys?: readonly HysVirtualTableKey[];
+    selectionType?: "checkbox" | "radio";
+    selectionWidth?: number;
+    reserveSelection?: boolean;
+    selectOnClick?: boolean;
+    currentRowKey?: HysVirtualTableKey | null;
+    defaultCurrentRowKey?: HysVirtualTableKey | null;
+    highlightCurrentRow?: boolean;
+    keyboard?: boolean;
+    endReachedThreshold?: number;
+    ariaLabel?: string;
+    rowClassName?: string | ((row: T, index: number) => string);
+    rowStyle?: CSSProperties | ((row: T, index: number) => CSSProperties);
+    cellClassName?: string | ((context: HysVirtualTableCell<T>) => string);
+    cellStyle?: CSSProperties | ((context: HysVirtualTableCell<T>) => CSSProperties);
+    customRow?: (row: T, index: number) => HTMLAttributes;
+    customCell?: (context: HysVirtualTableCell<T>) => HTMLAttributes;
+    customHeaderCell?: (column: HysVirtualTableColumn<T>, index: number) => HTMLAttributes;
+}
+export interface HysVirtualTableInstance<T extends object = Record<string, unknown>> {
+    readonly element: HTMLElement | undefined;
+    readonly viewport: HTMLElement | undefined;
+    readonly scrollTop: number;
+    readonly scrollLeft: number;
+    readonly range: HysVirtualTableRange;
+    readonly selectedRowKeys: HysVirtualTableKey[];
+    readonly sortState: HysVirtualTableSort | null;
+    scrollTo(options: {
+        top?: number;
+        left?: number;
+        behavior?: ScrollBehavior;
+    }): void;
+    scrollToRow(index: number, align?: HysVirtualTableAlign): void;
+    scrollToKey(key: HysVirtualTableKey, align?: HysVirtualTableAlign): boolean;
+    scrollToColumn(key: string, align?: HysVirtualTableAlign): boolean;
+    focusCell(index: number, key?: string): Promise<boolean>;
+    setSort(sort: HysVirtualTableSort | null): Promise<boolean>;
+    clearSelection(): Promise<boolean>;
+    toggleRowSelection(key: HysVirtualTableKey, selected?: boolean): Promise<boolean>;
+    selectAll(selected?: boolean): Promise<boolean>;
+    setCurrentRow(key: HysVirtualTableKey | null): Promise<boolean>;
+    getRow(index: number): T | undefined;
+    remeasure(): void;
+}
+export declare const virtualFinite: (value: unknown, fallback: number, min?: number, max?: number) => number;
+export declare const virtualKey: (key: unknown) => key is HysVirtualTableKey;
+export declare const virtualToken: (key: HysVirtualTableKey) => string;
+export declare function virtualValue<T extends object>(row: T, column: HysVirtualTableColumn<T>, index: number): unknown;
+export interface VirtualEntry<T extends object> {
+    row: T;
+    key: HysVirtualTableKey;
+    token: string;
+    sourceIndex: number;
+    valid: boolean;
+}
+export declare function virtualEntries<T extends object>(rows: readonly T[], rowKey: HysVirtualTableProps<T>["rowKey"]): VirtualEntry<T>[];
+export declare function virtualAligned(start: number, size: number, scroll: number, extent: number, align: HysVirtualTableAlign): number;

package/dist/types/index.d.ts

@@ -10,6 +10,8 @@ export { default as HysAvatarGroup } from './components/HysAvatarGroup/HysAvatar
 export { default as HysBadge } from './components/HysBadge/HysBadge.vue';
 export { default as HysBreadcrumb } from './components/HysBreadcrumb/HysBreadcrumb.vue';
 export type { HysBreadcrumbItem } from './components/HysBreadcrumb/HysBreadcrumb.vue';
+export type { HysBreadcrumbSelectInfo } from './components/HysBreadcrumb/HysBreadcrumb.vue';
+export type { HysBreadcrumbProps } from './components/HysBreadcrumb/HysBreadcrumb.vue';
 export { default as HysButton } from './components/HysButton/HysButton.vue';
 export type { HysButtonVariant } from './components/HysButton/HysButton.vue';
 export type { HysButtonProps } from './components/HysButton/HysButton.vue';
@@ -29,7 +31,6 @@ export type { Comment } from './components/HysCommentEditor/HysCommentEditor.vue
 export { default as HysContextMenu } from './components/HysContextMenu/HysContextMenu.vue';
 export { default as HysCronEditor } from './components/HysCronEditor/HysCronEditor.vue';
 export { default as HysDataGrid } from './components/HysDataGrid/HysDataGrid.vue';
-export type { GridColumn } from './components/HysDataGrid/HysDataGrid.vue';
 export { default as HysDatePicker } from './components/HysDatePicker/HysDatePicker.vue';
 export { default as HysDateRangePicker } from './components/HysDateRangePicker/HysDateRangePicker.vue';
 export { default as HysDiffViewer } from './components/HysDiffViewer/HysDiffViewer.vue';
@@ -92,7 +93,6 @@ export { default as HysTransfer } from './components/HysTransfer/HysTransfer.vue
 export { default as HysTree } from './components/HysTree/HysTree.vue';
 export { default as HysTreeSelect } from './components/HysTreeSelect/HysTreeSelect.vue';
 export { default as HysUpload } from './components/HysUpload/HysUpload.vue';
-export type { HysUploadFile } from './components/HysUpload/HysUpload.vue';
 export { default as HysVirtualTable } from './components/HysVirtualTable/HysVirtualTable.vue';
 export { provideHysConfig } from './config';
 export type { HysConfig, HysTheme, HysMotion } from './config';
@@ -119,3 +119,18 @@ export type { TreeNode, HysTreeKey, HysTreeValue, HysTreeNode, HysTreeFieldNames
 export type { HysTreeSelectNode, HysTreeSelectDataNode, HysTreeSelectLabelValue, HysTreeSelectValue, HysTreeSelectFieldNames, HysTreeSelectSimpleMode, HysTreeSelectStrategy, HysTreeSelectItem, HysTreeSelectChange, HysTreeSelectProps, HysTreeSelectInstance } from './composables/treeSelect';
 export type { HysCascaderKey, HysCascaderPath, HysCascaderValue, HysCascaderDataNode, HysCascaderNode, HysCascaderFieldNames, HysCascaderItem, HysCascaderOptionContext, HysCascaderLoadContext, HysCascaderChange, HysCascaderLocale, HysCascaderProps, HysCascaderInstance } from './composables/cascader';
 export type { HysDatePickerWeek, HysDateScalar, HysDatePickerValue, HysDateRangeValue, HysDatePickerType, HysDatePickerUnit, HysDatePickerView, HysDatePoint, HysDatePickerContext, HysDateDisabledTime, HysDateShortcut, HysDatePickerCell, HysDatePickerChange, HysDatePickerLocale, HysDatePickerProps, HysDateRangePickerProps, HysDatePickerInstance, HysDateRangePickerInstance, HysDatePickerSlots } from './composables/datePicker';
+export type { HysModalDragEffect, HysModalSectionSize, HysModalSizeName, HysModalBeforeClose, HysModalCloseReason, HysModalType, HysModalInitialFocus, HysModalActionContext, HysModalPosition, HysModalSize, HysModalProps, HysModalSlotContext, HysModalSlots, HysModalInstance } from './composables/modal';
+export { useHysModal, createHysModal } from './composables/useHysModal';
+export type { HysModalResult, HysModalOptions, HysModalHandle, HysModalConfig, HysModalApi, HysModalService, HysModalServiceConfig } from './composables/useHysModal';
+export type { HysMenuKey, HysContextMenuTrigger, HysContextMenuItem, HysMenuFieldNames, HysMenuSelectInfo, HysMenuShowOptions, HysContextMenuProps, HysContextMenuInstance, HysMenuItemContext, HysContextMenuSlots } from './composables/menu';
+export type { HysDrawerProps, HysDrawerBeforeClose, HysDrawerPlacement, HysDrawerSizeName, HysDrawerCloseReason, HysDrawerActionContext, HysDrawerInitialFocus, HysDrawerSectionSize, HysDrawerResizeOptions, HysDrawerResizeInfo, HysDrawerPushOptions, HysDrawerSlotContext, HysDrawerSlots, HysDrawerInstance } from './composables/drawer';
+export type { HysPopupPlacement, HysPopupTrigger, HysPopupVirtualReference, HysPopupReference, HysPopupSurfaceProps, HysTooltipProps, HysPopoverProps, HysPopupSurfaceContext, HysTooltipSlots, HysPopoverSlots, HysPopupSurfaceInstance, HysTooltipInstance, HysPopoverInstance } from './composables/popupSurface';
+export type { HysUploadFile, HysUploadItem, HysUploadStatus, HysUploadListType, HysUploadChangeType, HysUploadChange, HysUploadContext, HysUploadInvalid, HysUploadError, HysUploadDataScalar, HysUploadData, HysUploadRequestOptions, HysUploadRequestResult, HysUploadLocale, HysUploadProps, HysUploadActions, HysUploadFileContext, HysUploadSlotContext, HysUploadSlots, HysUploadInstance } from './composables/upload';
+export type { HysProgressType, HysProgressStatus, HysProgressSize, HysProgressLinecap, HysProgressGapPosition, HysProgressGradientDirection, HysProgressGradientStop, HysProgressGradient, HysProgressColorStop, HysProgressColor, HysProgressSuccess, HysProgressLabelContext, HysProgressProps, HysProgressSlots, HysProgressInstance } from './composables/progress';
+export type { HysAlertTone, HysAlertEffect, HysAlertTransition, HysAlertCloseContext, HysAlertProps, HysAlertSlotContext, HysAlertSlots, HysAlertInstance, HysEmptyIllustration, HysEmptyProps, HysEmptySlotContext, HysEmptySlots, HysEmptyInstance } from './composables/feedback';
+export type { HysTimelineKey, HysTimelineMode, HysTimelinePosition, HysTimelineSize, HysTimelineTone, HysTimelineItem, HysTimelineFieldNames, HysTimelineProps, HysTimelineItemContext, HysTimelinePendingContext, HysTimelineSlots, HysTimelineInstance } from './composables/timeline';
+export type { HysTagInputReason, HysTagInputAddContext, HysTagInputInvalid, HysTagInputProps, HysTagInputSlotContext, HysTagInputTagContext, HysTagInputSlots, HysTagInputInstance } from './composables/tagInput';
+export type { HysColorFormat, HysColor, HysColorPickerProps, HysColorPickerContext, HysColorPickerSlots, HysColorPickerInstance } from './composables/color';
+export type { HysVirtualTableKey, HysVirtualTableAlign, HysVirtualTableSort, HysVirtualTableCell, HysVirtualTableColumn, HysVirtualTableRange, HysVirtualTableScroll, HysVirtualTableProps, HysVirtualTableInstance } from './composables/virtualTable';
+export type { GridColumn, HysDataGridKey, HysDataGridSort, HysDataGridQuery, HysDataGridProps, HysDataGridResult, HysDataGridLoader, HysDataGridInstance } from './composables/dataGrid';
+export type { HysPopupTransition, HysPopupMotionProps } from './motion/popup';

package/dist/types/internal/PopupReference.d.ts

@@ -0,0 +1,18 @@
+import { type VNode } from "vue";
+/** Adds popup ARIA to the real control without introducing another keyboard stop. */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    id: StringConstructor;
+    open: BooleanConstructor;
+    kind: StringConstructor;
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "element"[], "element", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    id: StringConstructor;
+    open: BooleanConstructor;
+    kind: StringConstructor;
+}>> & Readonly<{
+    onElement?: ((...args: any[]) => any) | undefined;
+}>, {
+    open: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/internal/PopupSurfacePanel.vue.d.ts

@@ -0,0 +1,37 @@
+import type { HysPopupSurfaceProps } from "../composables/popupSurface";
+import type { usePopupSurface } from "../composables/usePopupSurface";
+type __VLS_Props = {
+    surface: ReturnType<typeof usePopupSurface>;
+    options: HysPopupSurfaceProps;
+    kind: "tooltip" | "popover";
+    title?: string;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        title?: (props: {
+            open: boolean;
+            show: () => Promise<boolean>;
+            close: () => Promise<boolean>;
+            toggle: () => Promise<boolean>;
+            updatePosition: () => void;
+        }) => any;
+    } & {
+        default?: (props: {
+            open: boolean;
+            show: () => Promise<boolean>;
+            close: () => Promise<boolean>;
+            toggle: () => Promise<boolean>;
+            updatePosition: () => void;
+        }) => 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<{}>, {}, {}, {}, {}, 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;
+    };
+};

package/dist/types/motion/PopupMotion.d.ts

@@ -0,0 +1,59 @@
+import { type PropType } from "vue";
+import type { HysPopupTransition } from "./popup";
+/** Internal transparent boundary: preserves the popup DOM/ref and owns only its transition. */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    popupTransition: {
+        type: PropType<HysPopupTransition>;
+        default: undefined;
+    };
+    popupTransitionDuration: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    placement: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ignoreOwner: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("left" | "inactive" | "entered")[], "left" | "inactive" | "entered", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    popupTransition: {
+        type: PropType<HysPopupTransition>;
+        default: undefined;
+    };
+    popupTransitionDuration: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    placement: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ignoreOwner: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onLeft?: ((...args: any[]) => any) | undefined;
+    onInactive?: ((...args: any[]) => any) | undefined;
+    onEntered?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    popupTransition: HysPopupTransition;
+    popupTransitionDuration: number;
+    placement: string;
+    ignoreOwner: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/motion/popup.d.ts

@@ -0,0 +1,12 @@
+export type HysPopupTransition = "scale" | "fade" | "slide" | "slide-fade" | "none";
+export interface HysPopupMotionProps {
+    /** Built-in entrance/exit effect. Defaults to scale; none disables it. */
+    popupTransition?: HysPopupTransition;
+    /** Duration in milliseconds, default 160. Zero disables the transition. */
+    popupTransitionDuration?: number;
+}
+/** Layout dimensions, unaffected by an in-flight scale/slide animation. */
+export declare function popupSize(element: HTMLElement): {
+    width: number;
+    height: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hys-ui",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Themeable Vue 3 components with TypeScript and interactive documentation",
   "type": "module",
   "license": "MIT",