hys-ui 0.1.1 → 0.2.0

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

@@ -0,0 +1,45 @@
+export type HysNumberInputValue = number | string | null;
+export interface HysNumberInputFormatInfo {
+    userTyping: boolean;
+    input: string;
+}
+export interface HysNumberInputStepInfo {
+    offset: number | string;
+    type: "up" | "down";
+    source: "button" | "keyboard" | "wheel" | "repeat" | "method";
+}
+export interface HysNumberInputInvalidInfo {
+    input: string;
+    reason: "parse" | "validator" | "range";
+}
+export interface HysNumberInputInstance {
+    input: HTMLInputElement | undefined;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    select: () => void;
+    clear: () => void;
+    commit: () => boolean;
+    increase: (multiplier?: number) => void;
+    decrease: (multiplier?: number) => void;
+}
+export interface Decimal {
+    units: bigint;
+    scale: number;
+}
+export declare function decimal(value: unknown): Decimal | undefined;
+export declare function decimalCompare(a: Decimal, b: Decimal): 0 | 1 | -1;
+export declare function decimalAdd(a: Decimal, b: Decimal, multiplier?: number): {
+    units: bigint;
+    scale: number;
+};
+export declare function decimalRound(value: Decimal, precision: number): Decimal;
+export declare function decimalText(value: Decimal, padTo?: number): string;
+export interface NumberConstraints {
+    step: Decimal;
+    base: Decimal;
+    min?: Decimal;
+    max?: Decimal;
+    precision?: number;
+    strict: boolean;
+}
+export declare function normalizeDecimal(value: Decimal, options: NumberConstraints): Decimal | undefined;

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,44 @@
+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;
+    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,309 @@
+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> {
+    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/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;