hys-ui 0.1.1 → 0.3.0

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

@@ -0,0 +1,92 @@
+import type { VNodeChild } from "vue";
+export type HysProgressType = "line" | "circle" | "dashboard";
+export type HysProgressStatus = "normal" | "success" | "warning" | "error" | "active";
+export type HysProgressSize = "sm" | "md" | "lg";
+export type HysProgressLinecap = "round" | "butt" | "square";
+export type HysProgressGapPosition = "top" | "right" | "bottom" | "left";
+export type HysProgressGradientDirection = number | "to right" | "to left" | "to top" | "to bottom" | "to top right" | "to top left" | "to bottom right" | "to bottom left";
+export interface HysProgressGradientStop {
+    offset: number;
+    color: string;
+}
+export interface HysProgressGradient {
+    from: string;
+    to: string;
+    direction?: HysProgressGradientDirection;
+    stops?: readonly HysProgressGradientStop[];
+}
+export interface HysProgressColorStop {
+    value: number;
+    color: string;
+}
+export type HysProgressColor = string | ((value: number) => string) | readonly HysProgressColorStop[] | readonly string[] | HysProgressGradient;
+export interface HysProgressSuccess {
+    value: number;
+    color?: HysProgressColor;
+}
+export interface HysProgressLabelContext {
+    value: number;
+    successValue: number;
+    status: HysProgressStatus;
+    indeterminate: boolean;
+}
+export interface HysProgressProps {
+    value: number;
+    showLabel?: boolean;
+    color?: HysProgressColor;
+    status?: HysProgressStatus;
+    strokeWidth?: number;
+    type?: HysProgressType;
+    width?: number | string;
+    format?: (value: number, successValue: number) => VNodeChild;
+    indeterminate?: boolean;
+    size?: HysProgressSize;
+    textInside?: boolean;
+    textColor?: string;
+    precision?: number;
+    showStatusIcon?: boolean;
+    trailColor?: string;
+    strokeLinecap?: HysProgressLinecap;
+    success?: HysProgressSuccess;
+    steps?: number;
+    stepGap?: number;
+    gapDegree?: number;
+    gapPosition?: HysProgressGapPosition;
+    striped?: boolean;
+    stripedFlow?: boolean;
+    animated?: boolean;
+    duration?: number;
+    flowDuration?: number;
+    ariaLabel?: string;
+    ariaValueText?: string | ((context: HysProgressLabelContext) => string);
+}
+export interface HysProgressSlots {
+    default?: (context: HysProgressLabelContext) => VNodeChild;
+    icon?: (context: HysProgressLabelContext) => VNodeChild;
+}
+export interface HysProgressInstance {
+    readonly element: HTMLElement | undefined;
+    readonly value: number;
+    readonly successValue: number;
+    readonly status: HysProgressStatus;
+}
+export declare const progressPercent: (value: number | undefined) => number;
+export declare const progressNumber: (value: number | undefined, fallback: number, min: number, max: number) => number;
+export declare const progressStatusColor: (status: HysProgressStatus) => string;
+export type ProgressPaint = {
+    color: string;
+    gradient?: {
+        stops: HysProgressGradientStop[];
+        angle: number;
+    };
+};
+export declare function progressPaint(color: HysProgressColor | undefined, value: number, fallback: string): ProgressPaint;
+export declare function progressCssPaint(paint: ProgressPaint): string;
+export declare function progressGradientCoordinates(degrees: number): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export declare function progressArc(radius: number, start: number, degrees: number): string;
+export declare const progressId: () => string;

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

@@ -0,0 +1,18 @@
+import type { Component } from "vue";
+export type HysRatingIcon = Component | string;
+export type HysRatingLevels<T> = readonly T[] | Record<number, T | {
+    value: T;
+    excluded?: boolean;
+}>;
+export interface HysRatingInstance {
+    element: HTMLElement | undefined;
+    value: number;
+    hoverValue: number | null;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    setValue: (value: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    setCurrentValue: (value: number) => void;
+    resetCurrentValue: () => void;
+}
+export declare function ratingLevel<T>(levels: HysRatingLevels<T> | undefined, value: number, low: number, high: number, fallback: T): T;

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

@@ -0,0 +1,15 @@
+import type { Component, CSSProperties } from "vue";
+import type { HysChoiceOption, HysChoiceValue } from "./choice";
+export interface HysSegmentedOption<T extends HysChoiceValue = HysChoiceValue> extends HysChoiceOption<T> {
+    icon?: Component | string;
+    title?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface HysSegmentedInstance {
+    element: HTMLElement | undefined;
+    value: HysChoiceValue | null;
+    focus: (value?: HysChoiceValue) => void;
+    blur: () => void;
+    select: (value: HysChoiceValue) => Promise<boolean>;
+}

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

@@ -0,0 +1,46 @@
+export type HysSelectValue = string | number | boolean | Record<string, unknown>;
+export type HysSelectModelValue = HysSelectValue | HysSelectValue[] | null;
+export interface HysSelectOption {
+    label: string;
+    value: HysSelectValue;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export interface HysSelectGroup {
+    label: string;
+    options: HysSelectOption[];
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export type HysSelectDataOption = HysSelectOption | HysSelectGroup | Record<string, unknown>;
+export interface HysSelectFieldNames {
+    label?: string;
+    value?: string;
+    options?: string;
+    disabled?: string;
+}
+export interface HysSelectSearchContext {
+    signal: AbortSignal;
+}
+export interface HysSelectInstance {
+    focus: () => void;
+    blur: () => void;
+    open: () => Promise<void>;
+    close: () => void;
+    scrollTo: (value: HysSelectValue) => void;
+    retry: () => void;
+    selectAll: () => number;
+    deselectAll: () => number;
+    selected: HysSelectOption[];
+    query: string;
+    isOpen: boolean;
+}
+export interface HysSelectRow {
+    key: string;
+    option?: HysSelectOption;
+    group?: string;
+    index: number;
+    created?: boolean;
+}
+export declare function selectKeyFactory(valueKey: () => string): (value: HysSelectValue) => string;
+export declare function normalizeSelectOptions(options: readonly HysSelectDataOption[], names: HysSelectFieldNames, keyOf: (value: HysSelectValue) => string): HysSelectRow[];

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

@@ -0,0 +1,21 @@
+import type { CSSProperties } from "vue";
+export type HysSliderValue = number | [number, number];
+export type HysSliderStep = number | "mark" | null;
+export type HysSliderMarks = Record<number, string | {
+    label: string;
+    style?: CSSProperties;
+}>;
+export interface HysSliderDragInfo {
+    index: number;
+    track: boolean;
+    cancelled: boolean;
+}
+export interface HysSliderInstance {
+    element: HTMLElement | undefined;
+    dragging: boolean;
+    values: number[];
+    focus: (index?: number) => void;
+    blur: () => void;
+    setValue: (value: HysSliderValue) => void;
+    cancel: () => void;
+}

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

@@ -0,0 +1,312 @@
+import type { HysPopupTransition } from '../motion/popup';
+import type { CSSProperties, HTMLAttributes, VNodeChild } from "vue";
+import type { Placement } from "./useFloating";
+export type HysTableKey = string | number;
+export type HysTableDirection = "asc" | "desc";
+export type HysTableFilterValue = string | number | boolean;
+export type HysTableFilters = Record<string, readonly HysTableFilterValue[]>;
+export interface HysTableSort {
+    key: string;
+    direction: HysTableDirection;
+}
+export interface HysTableSelectionProps {
+    disabled?: boolean;
+    label?: string;
+    title?: string;
+}
+export interface HysTableSelectionColumn {
+    label?: string;
+    width?: number;
+    fixed?: boolean | "left" | "right";
+    align?: "left" | "center" | "right";
+}
+export interface HysTableFilterConfirmOptions {
+    closeDropdown?: boolean;
+}
+export interface HysTableFilterResetOptions extends HysTableFilterConfirmOptions {
+    confirm?: boolean;
+}
+export interface HysTableScrollRowOptions {
+    behavior?: ScrollBehavior;
+    block?: "start" | "center" | "end" | "nearest";
+}
+export interface HysTableFilter {
+    label: string;
+    value: HysTableFilterValue;
+    disabled?: boolean;
+    children?: readonly HysTableFilter[];
+}
+export type HysTableElementAttrs = HTMLAttributes & Record<string, unknown>;
+export type HysTablePaginationPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+export interface HysTableCellContext<T extends object = Record<string, unknown>> {
+    row: T;
+    column: HysTableColumn<T>;
+    value: unknown;
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface HysTableColumn<T extends object = any> {
+    key: string;
+    label: string;
+    dataIndex?: string | readonly (string | number)[];
+    type?: "default" | "selection" | "index" | "expand";
+    children?: readonly HysTableColumn<T>[];
+    width?: string | number;
+    minWidth?: number;
+    maxWidth?: number;
+    fixed?: boolean | "left" | "right";
+    align?: "left" | "center" | "right";
+    headerAlign?: "left" | "center" | "right";
+    sortable?: boolean | "custom";
+    sorter?: (a: T, b: T) => number;
+    sortBy?: string | ((row: T) => unknown) | readonly (string | ((row: T) => unknown))[];
+    sortOrders?: readonly (HysTableDirection | null)[];
+    defaultSortOrder?: HysTableDirection;
+    sortPriority?: number;
+    filters?: readonly HysTableFilter[];
+    filterable?: boolean;
+    filterMultiple?: boolean;
+    filterMode?: "menu" | "tree";
+    filterSearch?: boolean | ((query: string, option: HysTableFilter) => boolean);
+    defaultFilterValue?: readonly HysTableFilterValue[];
+    filterResetToDefault?: boolean;
+    filterMethod?: (value: HysTableFilterValue, row: T, column: HysTableColumn<T>) => boolean;
+    formatter?: (row: T, column: HysTableColumn<T>, value: unknown, index: number) => VNodeChild;
+    ellipsis?: boolean;
+    showOverflowTooltip?: boolean;
+    tooltipFormatter?: (context: HysTableCellContext<T>) => VNodeChild;
+    className?: string;
+    headerClassName?: string;
+    cellStyle?: CSSProperties | ((context: HysTableCellContext<T>) => CSSProperties);
+    summary?: "sum" | "avg" | "min" | "max" | "count";
+    index?: number | ((index: number, row: T) => VNodeChild);
+    hidden?: boolean;
+    responsive?: readonly ("xs" | "sm" | "md" | "lg" | "xl" | "xxl")[];
+    resizable?: boolean;
+    rowScope?: "row" | "rowgroup";
+    customCell?: (context: HysTableCellContext<T>) => HysTableElementAttrs;
+    customHeaderCell?: (column: HysTableColumn<T>, index: number) => HysTableElementAttrs;
+}
+export interface HysTablePagination {
+    position?: readonly HysTablePaginationPosition[];
+    page?: number;
+    pageSize?: number;
+    total?: number;
+    pageSizeOptions?: number[];
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: boolean;
+    compact?: boolean;
+    hideOnSinglePage?: boolean;
+}
+export interface HysTableQuery<T extends object = Record<string, unknown>> {
+    action: "sort" | "filter" | "page" | "pageSize";
+    page: number;
+    pageSize: number;
+    sorts: HysTableSort[];
+    filters: HysTableFilters;
+    currentData: T[];
+}
+export interface HysTableLoadContext {
+    signal: AbortSignal;
+    key: HysTableKey;
+    depth: number;
+}
+export interface HysTableLocale {
+    emptyText: string;
+    loadingText: string;
+    selectAll: string;
+    selectRow: string;
+    expandRow: string;
+    collapseRow: string;
+    expand: string;
+    collapse: string;
+    filter: string;
+    filterPlaceholder: string;
+    reset: string;
+    apply: string;
+    retry: string;
+    retryLabel: string;
+    scrollLabel: string;
+    resizeColumn: string;
+    sortAsc: string;
+    sortDesc: string;
+    filterSearch?: string;
+    noFilterMatch?: string;
+    invertSelection?: string;
+    clearSelection?: string;
+    selected?: string;
+    paginationLabels?: Partial<{
+        total: string;
+        perPage: string;
+        jump: string;
+        page: string;
+        first: string;
+        previous: string;
+        next: string;
+        last: string;
+    }>;
+}
+export interface HysTableProps<T extends object> {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
+    locale?: Partial<HysTableLocale>;
+    columns: readonly HysTableColumn<T>[];
+    rows: readonly T[];
+    rowKey?: string | ((row: T) => HysTableKey);
+    emptyText?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    striped?: boolean;
+    bordered?: boolean;
+    size?: "sm" | "md" | "lg";
+    tableLayout?: "auto" | "fixed";
+    caption?: string;
+    height?: number | string;
+    maxHeight?: number | string;
+    stickyHeader?: boolean;
+    showHeader?: boolean;
+    fit?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarTabindex?: number | string;
+    headerRowClassName?: string | ((columns: readonly HysTableColumn<T>[], level: number) => string);
+    headerRowStyle?: CSSProperties | ((columns: readonly HysTableColumn<T>[], level: number) => CSSProperties);
+    rowClassName?: string | ((row: T, index: number) => string);
+    rowStyle?: CSSProperties | ((row: T, index: number) => CSSProperties);
+    cellClassName?: string | ((context: HysTableCellContext<T>) => string);
+    cellStyle?: CSSProperties | ((context: HysTableCellContext<T>) => CSSProperties);
+    headerCellClassName?: string | ((column: HysTableColumn<T>, index: number) => string);
+    headerCellStyle?: CSSProperties | ((column: HysTableColumn<T>, index: number) => CSSProperties);
+    customRow?: (row: T, index: number) => HysTableElementAttrs;
+    customHeaderRow?: (columns: readonly HysTableColumn<T>[], index: number) => HysTableElementAttrs;
+    customCell?: (context: HysTableCellContext<T>) => HysTableElementAttrs;
+    customHeaderCell?: (column: HysTableColumn<T>, index: number) => HysTableElementAttrs;
+    selectable?: boolean | ((row: T, index: number) => boolean);
+    selectionType?: "checkbox" | "radio";
+    selectedRowKeys?: readonly HysTableKey[];
+    defaultSelectedRowKeys?: readonly HysTableKey[];
+    reserveSelection?: boolean;
+    checkStrictly?: boolean;
+    selectOnIndeterminate?: boolean;
+    selectionActions?: boolean;
+    rangeSelection?: boolean;
+    hideSelectAll?: boolean;
+    selectionColumn?: HysTableSelectionColumn;
+    getSelectionProps?: (row: T, index: number) => HysTableSelectionProps;
+    highlightCurrentRow?: boolean;
+    currentRowKey?: HysTableKey | null;
+    defaultCurrentRowKey?: HysTableKey;
+    showIndex?: boolean;
+    indexMethod?: (index: number, row: T) => VNodeChild;
+    sort?: HysTableSort | null;
+    sorts?: readonly HysTableSort[];
+    defaultSort?: HysTableSort | readonly HysTableSort[] | null;
+    multiSort?: boolean;
+    sortOrders?: readonly (HysTableDirection | null)[];
+    filters?: HysTableFilters;
+    defaultFilters?: HysTableFilters;
+    filterColumnKey?: string | null;
+    filterPlacement?: Placement;
+    appendFilterTo?: string | HTMLElement | false;
+    pagination?: boolean | HysTablePagination;
+    page?: number;
+    pageSize?: number;
+    total?: number;
+    serverMode?: boolean;
+    scrollToFirstRowOnChange?: boolean;
+    expandable?: boolean;
+    expandedRowKeys?: readonly HysTableKey[];
+    defaultExpandedRowKeys?: readonly HysTableKey[];
+    defaultExpandAll?: boolean;
+    rowExpandable?: (row: T) => boolean;
+    expandOnClickRow?: boolean;
+    showExpandColumn?: boolean;
+    expandColumnTitle?: string;
+    expandFixed?: boolean | "left" | "right";
+    preserveExpandedContent?: boolean;
+    treeMode?: boolean;
+    childrenKey?: string;
+    hasChildrenKey?: string;
+    indent?: number;
+    loadChildren?: (row: T, context: HysTableLoadContext) => readonly T[] | Promise<readonly T[]>;
+    showSummary?: boolean;
+    sumText?: string;
+    summaryMethod?: (context: {
+        columns: readonly HysTableColumn<T>[];
+        rows: T[];
+    }) => readonly VNodeChild[] | Record<string, VNodeChild>;
+    spanMethod?: (context: HysTableCellContext<T>) => {
+        rowspan?: number;
+        colspan?: number;
+    } | readonly [number, number] | undefined;
+    showOverflowTooltip?: boolean;
+    tooltipFormatter?: (context: HysTableCellContext<T>) => VNodeChild;
+    resizable?: boolean;
+    columnWidths?: Readonly<Record<string, number>>;
+    allowDragLastColumn?: boolean;
+}
+export interface HysTableInstance<T extends object = Record<string, unknown>> {
+    readonly element: HTMLElement | undefined;
+    readonly viewport: HTMLElement | undefined;
+    readonly selectedKeys: HysTableKey[];
+    readonly currentRow: T | undefined;
+    readonly expandedKeys: HysTableKey[];
+    readonly query: HysTableQuery<T>;
+    readonly columns: HysTableColumn<T>[];
+    clearSelection: () => Promise<boolean>;
+    getSelectionRows: () => T[];
+    getHalfSelectionRows: () => T[];
+    toggleRowSelection: (row: T | HysTableKey, selected?: boolean, range?: boolean) => Promise<boolean>;
+    toggleAllSelection: (selected?: boolean) => Promise<boolean>;
+    invertSelection: () => Promise<boolean>;
+    setCurrentRow: (row?: T | HysTableKey | null) => Promise<boolean>;
+    toggleRowExpansion: (row: T | HysTableKey, expanded?: boolean) => Promise<boolean>;
+    loadRow: (row: T | HysTableKey, force?: boolean) => Promise<boolean>;
+    updateKeyChildren: (row: T | HysTableKey, children: readonly T[]) => Promise<boolean>;
+    clearSort: () => void;
+    setSort: (sort: HysTableSort | readonly HysTableSort[] | null) => void;
+    clearFilter: (keys?: readonly string[]) => void;
+    setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
+    showFilter: (key: string) => Promise<boolean>;
+    hideFilter: () => Promise<boolean>;
+    setPage: (page: number) => void;
+    resizeColumn: (key: string, width: number) => void;
+    resetColumnWidths: () => void;
+    doLayout: () => Promise<void>;
+    scrollTo: (options: ScrollToOptions) => void;
+    setScrollTop: (top: number) => void;
+    setScrollLeft: (left: number) => void;
+    scrollToRow: (row: T | HysTableKey, options?: HysTableScrollRowOptions) => Promise<boolean>;
+}
+export interface TableNode<T extends object> {
+    row: T;
+    key: HysTableKey;
+    token: string;
+    index: number;
+    depth: number;
+    rootToken: string;
+    parent?: TableNode<T>;
+    children: TableNode<T>[];
+    lazy: boolean;
+}
+export interface TableHeader<T extends object> {
+    column: HysTableColumn<T>;
+    key: string;
+    leaves: HysTableColumn<T>[];
+    colspan: number;
+    rowspan: number;
+    fixed?: "left" | "right";
+}
+export declare const tableToken: (key: HysTableKey) => string;
+export declare function tableValue(row: object, path: string | readonly (string | number)[]): unknown;
+export declare const tableBreakpoint: (width: number) => "sm" | "md" | "lg" | "xs" | "xl" | "xxl";
+export declare function tableColumns<T extends object>(input: readonly HysTableColumn<T>[], breakpoint: ReturnType<typeof tableBreakpoint>, showExpandColumn?: boolean): {
+    leaves: HysTableColumn<T>[];
+    headers: TableHeader<T>[][];
+};
+export declare function tableCompare<T extends object>(sorts: readonly HysTableSort[], columns: readonly HysTableColumn<T>[]): (a: T, b: T) => number;
+export declare function tableMatches<T extends object>(row: T, filters: HysTableFilters, columns: readonly HysTableColumn<T>[]): boolean;
+export declare function tableFilterPredicate<T extends object>(filters: HysTableFilters, columns: readonly HysTableColumn<T>[]): (row: T) => boolean;
+/** Iterative traversal also tolerates accidentally cyclic filter definitions. */
+export declare function tableFilterOptions(filters: readonly HysTableFilter[]): HysTableFilter[];
+export declare function tableSummary<T extends object>(rows: readonly T[], column: HysTableColumn<T>): number | "" | "—";

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

@@ -0,0 +1,96 @@
+import type { Component, VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../motion/popup";
+export type HysTagInputReason = "keyboard" | "blur" | "separator" | "paste" | "api";
+export interface HysTagInputAddContext {
+    signal: AbortSignal;
+    values: readonly string[];
+    reason: HysTagInputReason;
+}
+export interface HysTagInputInvalid {
+    value: string;
+    reason: "duplicate" | "max" | "guard" | "error" | "maxlength" | "minlength";
+    error?: Error;
+}
+export interface HysTagInputProps extends HysPopupMotionProps {
+    modelValue?: readonly string[];
+    defaultValue?: readonly string[];
+    max?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: "sm" | "md" | "lg";
+    addOnBlur?: boolean;
+    separator?: string;
+    delimiters?: string | readonly string[] | RegExp;
+    trigger?: "Enter" | "Space" | "Tab" | readonly string[];
+    beforeAdd?: (value: string, context: HysTagInputAddContext) => boolean | void | Promise<boolean | void>;
+    allowDuplicates?: boolean;
+    caseSensitive?: boolean;
+    trim?: boolean;
+    clearable?: boolean;
+    clearIcon?: Component;
+    tagTone?: "primary" | "success" | "warning" | "danger" | "neutral";
+    tagEffect?: "light" | "dark" | "outline";
+    tagRound?: boolean;
+    draggable?: boolean;
+    collapseTags?: boolean;
+    maxCollapseTags?: number;
+    collapseTagsTooltip?: boolean;
+    overflowHeight?: number;
+    maxTagTextLength?: number;
+    maxlength?: number;
+    minlength?: number;
+    ariaLabel?: string;
+    label?: string;
+    name?: string;
+    form?: string;
+    autocomplete?: string;
+    autofocus?: boolean;
+    tabindex?: number;
+    status?: "error" | "warning" | "success";
+    error?: string;
+    validateEvent?: boolean;
+    inputProps?: Record<string, unknown>;
+}
+export interface HysTagInputSlotContext {
+    values: readonly string[];
+    draft: string;
+    disabled: boolean;
+    readonly: boolean;
+    pending: boolean;
+    add: (value?: string | string[]) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+}
+export interface HysTagInputTagContext {
+    value: string;
+    index: number;
+    disabled: boolean;
+    readonly: boolean;
+    remove: () => Promise<boolean>;
+}
+export interface HysTagInputSlots {
+    tag?: (context: HysTagInputTagContext) => VNodeChild;
+    prefix?: (context: HysTagInputSlotContext) => VNodeChild;
+    suffix?: (context: HysTagInputSlotContext) => VNodeChild;
+    "clear-icon"?: (context: HysTagInputSlotContext) => VNodeChild;
+    "remove-icon"?: (context: HysTagInputTagContext) => VNodeChild;
+    "collapse-tag"?: (context: {
+        count: number;
+        values: readonly string[];
+    }) => VNodeChild;
+}
+export interface HysTagInputInstance {
+    readonly element: HTMLElement | undefined;
+    readonly input: HTMLInputElement | undefined;
+    readonly values: readonly string[];
+    readonly draft: string;
+    readonly pending: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    add: (value?: string | string[]) => Promise<boolean>;
+    remove: (index: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    move: (from: number, to: number) => Promise<boolean>;
+    setDraft: (value: string) => void;
+}
+export declare function splitTags(value: string, separator?: string | readonly string[] | RegExp): string[];

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

@@ -0,0 +1,76 @@
+import type { Component, InputHTMLAttributes, TextareaHTMLAttributes } from "vue";
+export interface HysInputFormatInfo {
+    userTyping: boolean;
+    input: string;
+}
+export interface HysInputCountInfo {
+    value: string;
+    count: number;
+    maxLength?: number;
+}
+export type HysInputCountStrategy = boolean | ((value: string) => number);
+export interface HysInputProps {
+    modelValue?: string | number | null;
+    defaultValue?: string | number | null;
+    placeholder?: string;
+    type?: string;
+    label?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    ariaLabel?: string;
+    error?: string;
+    status?: "error" | "warning" | "success";
+    clearable?: boolean;
+    clearIcon?: Component;
+    prefixIcon?: Component;
+    suffixIcon?: Component;
+    showPassword?: boolean;
+    showPasswordOn?: "click" | "mousedown";
+    passwordVisible?: boolean;
+    defaultPasswordVisible?: boolean;
+    showCount?: boolean | {
+        formatter: (info: HysInputCountInfo) => string;
+    };
+    showWordLimit?: boolean;
+    countPosition?: "inside" | "outside";
+    wordLimitPosition?: "inside" | "outside";
+    countGraphemes?: HysInputCountStrategy;
+    maxlength?: number | string;
+    minlength?: number | string;
+    formatter?: (value: string, info: HysInputFormatInfo) => string;
+    parser?: (value: string) => string | number;
+    allowInput?: (value: string) => boolean;
+    autocomplete?: string;
+    name?: string;
+    size?: "sm" | "md" | "lg";
+    rows?: number;
+    autosize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    resize?: "none" | "both" | "horizontal" | "vertical";
+    inputProps?: InputHTMLAttributes | TextareaHTMLAttributes;
+    autofocus?: boolean;
+    selectOnFocus?: boolean;
+    bordered?: boolean;
+    round?: boolean;
+}
+export interface HysInputInstance {
+    input: HTMLInputElement | HTMLTextAreaElement | undefined;
+    textarea: HTMLTextAreaElement | undefined;
+    isComposing: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    select: () => void;
+    clear: () => void;
+    resize: () => Promise<void>;
+    setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none") => void;
+    scrollTo: (options: ScrollToOptions) => void;
+}
+export type HysTextareaProps = Omit<HysInputProps, 'type' | 'showPassword' | 'showPasswordOn' | 'passwordVisible' | 'defaultPasswordVisible'>;
+export interface HysTextareaInstance extends Omit<HysInputInstance, 'input'> {
+    input: HTMLTextAreaElement | undefined;
+}
+export declare function textCount(value: string, strategy?: HysInputCountStrategy): number;
+export declare function textLimit(value: string, max: number | undefined, strategy?: HysInputCountStrategy): string;
+export declare function textLengthLimit(value?: string | number): number | undefined;