hys-ui 0.1.1 → 0.3.0

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

@@ -1,70 +1,58 @@
-export interface HysUploadFile {
-    uid: string;
-    name: string;
-    size: number;
-    raw: File;
-}
-type __VLS_Props = {
-    accept?: string;
-    multiple?: boolean;
-    disabled?: boolean;
-    limit?: number;
-    maxSize?: number;
-    drag?: boolean;
-    showFileList?: boolean;
-    beforeUpload?: (file: File) => boolean | void | Promise<boolean | void>;
+import { type HysUploadProps, type HysUploadFile, type HysUploadItem, type HysUploadSlots, type HysUploadChange, type HysUploadInvalid, type HysUploadError } from "../../composables/upload";
+export type { HysUploadFile } from "../../composables/upload";
+declare const __VLS_export: <T extends HysUploadItem = HysUploadFile>(__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<HysUploadProps<T> & {
+        onChange?: ((files: T[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((files: T[]) => any) | undefined;
+        onProgress?: ((percentage: number, file: T) => any) | undefined;
+        onSelect?: ((files: File[]) => any) | undefined;
+        onSuccess?: ((response: unknown, file: T) => any) | undefined;
+        onAbort?: ((file: T, reason: string) => any) | undefined;
+        onDrop?: ((event: DragEvent) => any) | undefined;
+        onError?: ((message: string) => any) | undefined;
+        onInvalid?: ((info: HysUploadInvalid<T>) => any) | undefined;
+        onPaste?: ((event: ClipboardEvent) => any) | undefined;
+        onStart?: ((file: T) => any) | undefined;
+        onRemove?: ((file: T) => any) | undefined;
+        onPreview?: ((file: T) => any) | undefined;
+        onDownload?: ((file: T) => any) | undefined;
+        "onUpdate:fileList"?: ((files: T[]) => any) | undefined;
+        onFileChange?: ((change: HysUploadChange<T>) => any) | undefined;
+        onUploadError?: ((error: HysUploadError, file: T) => any) | undefined;
+        onExceed?: ((files: File[]) => any) | undefined;
+        onRemoveError?: ((error: Error, file: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        files: import("vue").ComputedRef<T[]>;
+        busy: import("vue").Ref<boolean, boolean>;
+        uploading: import("vue").ComputedRef<number>;
+        queued: import("vue").ComputedRef<number>;
+        open: (event?: Event) => void;
+        focus: () => void;
+        addFiles: (inputFiles: readonly File[]) => Promise<T[]>;
+        getFiles: () => T[];
+        clearFiles: (statuses?: readonly import("../../index.js").HysUploadStatus[]) => Promise<boolean>;
+        remove: (file: string | T) => Promise<boolean>;
+        submit: (file?: T | string) => Promise<number>;
+        retry: (file: T | string) => Promise<boolean>;
+        abort: (file?: T | string) => number;
+        preview: (file: string | T) => Promise<boolean>;
+        download: (file: string | T) => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: HysUploadSlots<T>;
+    emit: ((evt: "change", files: T[]) => void) & ((evt: "update:modelValue", files: T[]) => void) & ((evt: "progress", percentage: number, file: T) => void) & ((evt: "select", files: File[]) => void) & ((evt: "success", response: unknown, file: T) => void) & ((evt: "abort", file: T, reason: string) => void) & ((evt: "drop", event: DragEvent) => void) & ((evt: "error", message: string) => void) & ((evt: "invalid", info: HysUploadInvalid<T>) => void) & ((evt: "paste", event: ClipboardEvent) => void) & ((evt: "start", file: T) => void) & ((evt: "remove", file: T) => void) & ((evt: "preview", file: T) => void) & ((evt: "download", file: T) => void) & ((evt: "update:fileList", files: T[]) => void) & ((evt: "fileChange", change: HysUploadChange<T>) => void) & ((evt: "uploadError", error: HysUploadError, file: T) => void) & ((evt: "exceed", files: File[]) => void) & ((evt: "removeError", error: Error, file: T) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        default?: (props: {}) => any;
-    } & {
-        file?: (props: {
-            file: {
-                uid: string;
-                name: string;
-                size: number;
-                raw: {
-                    readonly lastModified: number;
-                    readonly name: string;
-                    readonly webkitRelativePath: string;
-                    readonly size: number;
-                    readonly type: string;
-                    arrayBuffer: () => Promise<ArrayBuffer>;
-                    bytes: () => Promise<Uint8Array<ArrayBuffer>>;
-                    slice: (start?: number, end?: number, contentType?: string) => Blob;
-                    stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
-                    text: () => Promise<string>;
-                };
-            };
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    clearFiles: () => void;
-    open: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    change: (files: HysUploadFile[]) => any;
-    select: (files: File[]) => any;
-    error: (message: string) => any;
-    remove: (file: HysUploadFile) => any;
-    exceed: (files: File[]) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onChange?: ((files: HysUploadFile[]) => any) | undefined;
-    onSelect?: ((files: File[]) => any) | undefined;
-    onError?: ((message: string) => any) | undefined;
-    onRemove?: ((file: HysUploadFile) => any) | undefined;
-    onExceed?: ((files: File[]) => any) | undefined;
-}>, {
-    multiple: boolean;
-    drag: boolean;
-    showFileList: boolean;
-}, {}, {}, {}, 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;
-    };
-};
+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/HysVirtualTable/HysVirtualTable.vue.d.ts

@@ -1,45 +1,76 @@
-type Row = {
-    id: string | number;
-    [key: string]: unknown;
-};
-type Column = {
-    key: string;
-    label: string;
-    width?: number;
-};
-type __VLS_Props = {
-    rows: Row[];
-    columns: Column[];
-    rowHeight?: number;
-    height?: number;
-    loading?: boolean;
-    emptyText?: string;
-    rowKey?: string;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        [x: string]: ((props: {
-            row: Row;
-            value: unknown;
+import { type HysVirtualTableProps, type HysVirtualTableColumn, type HysVirtualTableCell, type HysVirtualTableKey, type HysVirtualTableSort, type HysVirtualTableRange, type HysVirtualTableScroll, type HysVirtualTableAlign } from "../../composables/virtualTable";
+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<HysVirtualTableProps<T> & {
+        onScroll?: ((state: HysVirtualTableScroll) => any) | undefined;
+        onSelectionChange?: ((keys: HysVirtualTableKey[], rows: T[]) => any) | undefined;
+        onRowClick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        "onUpdate:selectedRowKeys"?: ((keys: HysVirtualTableKey[]) => any) | undefined;
+        onSortChange?: ((sort: HysVirtualTableSort | null) => any) | undefined;
+        "onUpdate:currentRowKey"?: ((key: HysVirtualTableKey | null) => any) | undefined;
+        onCurrentChange?: ((row: T | null, key: HysVirtualTableKey | null) => any) | undefined;
+        onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onCellClick?: ((context: HysVirtualTableCell<T>, event: MouseEvent) => any) | undefined;
+        "onUpdate:sortState"?: ((sort: HysVirtualTableSort | null) => any) | undefined;
+        onRangeChange?: ((range: HysVirtualTableRange) => any) | undefined;
+        onEndReached?: ((info: {
+            distance: number;
+            total: number;
         }) => any) | undefined;
-    } & {
-        header?: (props: {
-            column: Column;
-        }) => any;
-    } & {
-        empty?: (props: {}) => any;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        viewport: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrollTop: import("vue").Ref<number, number>;
+        scrollLeft: import("vue").Ref<number, number>;
+        range: import("vue").ComputedRef<HysVirtualTableRange>;
+        selectedRowKeys: import("vue").ComputedRef<HysVirtualTableKey[]>;
+        sortState: import("vue").ComputedRef<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: (value: 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;
+        remeasure: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        [name: string]: ((props: any) => any) | undefined;
+        header?(props: {
+            column: HysVirtualTableColumn<T>;
+            columnIndex: number;
+        }): any;
+        cell?(props: HysVirtualTableCell<T>): any;
+        empty?(): any;
+        loading?(): any;
+        footer?(props: {
+            rows: readonly T[];
+            range: HysVirtualTableRange;
+            selectedRowKeys: HysVirtualTableKey[];
+        }): any;
     };
+    emit: ((evt: "scroll", state: HysVirtualTableScroll) => void) & ((evt: "selectionChange", keys: HysVirtualTableKey[], rows: T[]) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysVirtualTableKey[]) => void) & ((evt: "sortChange", sort: HysVirtualTableSort | null) => void) & ((evt: "update:currentRowKey", key: HysVirtualTableKey | null) => void) & ((evt: "currentChange", row: T | null, key: HysVirtualTableKey | null) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysVirtualTableCell<T>, event: MouseEvent) => void) & ((evt: "update:sortState", sort: HysVirtualTableSort | null) => void) & ((evt: "rangeChange", range: HysVirtualTableRange) => void) & ((evt: "endReached", info: {
+        distance: number;
+        total: number;
+    }) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-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<{}>, {
-    height: number;
-    rowHeight: number;
-}, {}, {}, {}, 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;
-    };
-};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,109 @@
+import type { HysPopupTransition } from '../motion/popup';
+import type { Component, CSSProperties } from "vue";
+import type { Placement } from "./useFloating";
+import type { HysInputProps } from "./textInput";
+export interface HysAutocompleteOption {
+    value?: string;
+    label?: string;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export type HysAutocompleteItem = string | HysAutocompleteOption;
+export interface HysAutocompleteGroup {
+    label: string;
+    options?: readonly HysAutocompleteDataOption[];
+    children?: readonly HysAutocompleteDataOption[];
+    disabled?: boolean;
+    key?: string | number;
+    type?: "group";
+}
+export type HysAutocompleteDataOption = HysAutocompleteItem | HysAutocompleteGroup;
+export interface HysAutocompleteContext {
+    signal: AbortSignal;
+}
+export type HysAutocompleteCallback = (options: readonly HysAutocompleteDataOption[]) => void;
+export type HysAutocompleteFetch = (query: string, callback: HysAutocompleteCallback, context: HysAutocompleteContext) => void | readonly HysAutocompleteDataOption[] | Promise<void | readonly HysAutocompleteDataOption[]>;
+export interface HysAutocompleteProps {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
+    modelValue?: string;
+    defaultValue?: string;
+    options?: readonly HysAutocompleteDataOption[];
+    fetchSuggestions?: HysAutocompleteFetch | readonly HysAutocompleteDataOption[];
+    valueKey?: string;
+    labelKey?: string;
+    filterOption?: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive?: boolean;
+    debounce?: number;
+    minQueryLength?: number;
+    triggerOnFocus?: boolean;
+    highlightFirst?: boolean;
+    loopNavigation?: boolean;
+    backfill?: boolean;
+    selectWhenUnmatched?: boolean;
+    selectOnTab?: boolean;
+    append?: boolean;
+    clearAfterSelect?: boolean;
+    blurAfterSelect?: boolean;
+    getShow?: (query: string) => boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    hideLoading?: boolean;
+    clearable?: boolean;
+    clearIcon?: Component;
+    placeholder?: string;
+    label?: string;
+    ariaLabel?: string;
+    name?: string;
+    status?: "error" | "warning" | "success";
+    error?: string;
+    size?: "sm" | "md" | "lg";
+    bordered?: boolean;
+    autofocus?: boolean;
+    inputProps?: Omit<HysInputProps, "modelValue" | "defaultValue">;
+    open?: boolean;
+    defaultOpen?: boolean;
+    placement?: Placement;
+    popupMatchWidth?: boolean;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    appendTo?: string | HTMLElement | false;
+    listHeight?: number;
+    emptyText?: string;
+    loadingText?: string;
+    errorText?: string;
+}
+export interface HysAutocompleteInstance {
+    input: HTMLInputElement | HTMLTextAreaElement | undefined;
+    isOpen: boolean;
+    loading: boolean;
+    highlightedIndex: number;
+    suggestions: readonly HysAutocompleteDataOption[];
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    open: () => Promise<void>;
+    close: () => void;
+    clear: () => void;
+    getData: () => Promise<void>;
+    retry: () => Promise<void>;
+    highlight: (index: number) => void;
+    select: (option: HysAutocompleteItem) => Promise<void>;
+}
+export interface HysAutocompleteRow {
+    key: string;
+    kind: "group" | "option";
+    label: string;
+    value: string;
+    disabled: boolean;
+    item: HysAutocompleteItem;
+    group?: HysAutocompleteGroup;
+}
+export declare function autocompleteValue(item: HysAutocompleteItem, key?: string, labelKey?: string): string;
+export declare function normalizeAutocomplete(data: readonly HysAutocompleteDataOption[], query: string, settings: {
+    valueKey: string;
+    labelKey: string;
+    filter: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive: boolean;
+}): HysAutocompleteRow[];

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

@@ -0,0 +1,73 @@
+import type { HysPopupTransition } from '../motion/popup';
+import { type Component, type ComputedRef, type CSSProperties, type ImgHTMLAttributes, type InjectionKey } from "vue";
+import type { Placement } from "./useFloating";
+export type HysAvatarBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export type HysAvatarSize = number | "sm" | "md" | "lg" | "small" | "medium" | "default" | "large" | Partial<Record<HysAvatarBreakpoint, number>>;
+export type HysAvatarFit = "cover" | "contain" | "fill" | "none" | "scale-down";
+export interface HysAvatarProps {
+    name?: string;
+    src?: string;
+    srcset?: string;
+    srcSet?: string;
+    sizes?: string;
+    size?: HysAvatarSize;
+    shape?: "circle" | "square";
+    fit?: HysAvatarFit;
+    alt?: string;
+    icon?: Component;
+    gap?: number;
+    autoFit?: boolean;
+    color?: string;
+    textColor?: string;
+    bordered?: boolean;
+    radius?: number | string;
+    fallbackSrc?: string;
+    loadError?: (event: Event) => boolean | void;
+    draggable?: boolean;
+    crossOrigin?: "" | "anonymous" | "use-credentials";
+    lazy?: boolean;
+    imgProps?: ImgHTMLAttributes;
+}
+export interface HysAvatarLoadInfo {
+    src: string;
+    fallback: boolean;
+}
+export interface HysAvatarInstance {
+    element: HTMLElement | undefined;
+    image: HTMLImageElement | undefined;
+    loaded: boolean;
+    failed: boolean;
+    reload: () => void;
+}
+export interface HysAvatarOption extends HysAvatarProps {
+    key?: string | number;
+}
+export interface HysAvatarGroupInstance {
+    open: () => Promise<void>;
+    close: () => void;
+}
+export interface HysAvatarGroupProps {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
+    options?: readonly HysAvatarOption[];
+    size?: HysAvatarSize;
+    shape?: "circle" | "square";
+    gap?: number;
+    maxCount?: number;
+    vertical?: boolean;
+    bordered?: boolean;
+    maxStyle?: CSSProperties;
+    maxClass?: string;
+    placement?: Placement;
+    trigger?: "hover" | "focus" | "click";
+    showOverflow?: boolean;
+    expandOnHover?: boolean;
+}
+export interface AvatarGroupContext {
+    size: ComputedRef<HysAvatarSize | undefined>;
+    shape: ComputedRef<"circle" | "square" | undefined>;
+    bordered: ComputedRef<boolean>;
+}
+export declare const avatarGroupKey: InjectionKey<AvatarGroupContext>;
+export declare function resolveAvatarSize(size: HysAvatarSize | undefined, viewport: number): number;
+export declare function useAvatarSize(size: ComputedRef<HysAvatarSize | undefined>): ComputedRef<number>;

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

@@ -0,0 +1,66 @@
+export type HysCalendarValue = string | Date;
+export type HysCalendarMode = "month" | "year";
+export type HysCalendarTransition = "none" | "fade" | "slide" | "slide-up" | "zoom";
+export type HysCalendarAction = "prev-month" | "next-month" | "prev-year" | "next-year" | "today";
+export interface CalendarEvent {
+    id: string;
+    date: string;
+    title: string;
+    end?: string;
+    time?: string;
+    color?: string;
+    disabled?: boolean;
+    description?: string;
+}
+export interface HysCalendarSelectInfo {
+    source: "date" | "month" | "keyboard" | "customize";
+}
+export interface HysCalendarCell {
+    day: string;
+    date: Date;
+    type: "prev-month" | "current-month" | "next-month";
+    isSelected: boolean;
+    isToday: boolean;
+    disabled: boolean;
+    events: CalendarEvent[];
+}
+export interface HysCalendarMonthCell {
+    month: number;
+    date: Date;
+    day: string;
+    isSelected: boolean;
+    isToday: boolean;
+    disabled: boolean;
+    events: CalendarEvent[];
+}
+export interface HysCalendarInstance<T extends HysCalendarValue = string> {
+    readonly element: HTMLElement | undefined;
+    readonly selectedDay: T | undefined;
+    readonly panelValue: T;
+    readonly currentMode: HysCalendarMode;
+    readonly visibleRange: readonly [string, string];
+    pickDay: (value: HysCalendarValue) => Promise<boolean>;
+    selectDate: (action: HysCalendarAction) => boolean;
+    showMonth: (value: HysCalendarValue) => boolean;
+    setMode: (mode: HysCalendarMode) => boolean;
+    focus: () => Promise<void>;
+}
+export declare function calendarDay(value: HysCalendarValue | undefined, format?: string): number | undefined;
+export declare function civilDay(y: number, m: number, d: number): number;
+export declare function calendarParts(day: number): {
+    year: number;
+    month: number;
+    day: number;
+    weekday: number;
+};
+export declare function calendarISO(day: number): string;
+export declare function calendarDate(day: number): Date;
+export declare function calendarFormat(day: number, format: string): string;
+export declare function calendarShift(day: number, months: number): number;
+export declare function calendarWeeks(start: number, end: number, first: number): [number, number];
+export declare function calendarWeek(day: number): number;
+/** Index only the bounded visible window, including intersecting multi-day events. */
+export declare function calendarEvents(events: readonly CalendarEvent[], start: number, end: number): {
+    dates: Map<number, CalendarEvent[]>;
+    months: Map<number, CalendarEvent[]>;
+};