hys-ui 0.1.0 → 0.2.0

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[]>;
+};

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

@@ -0,0 +1,192 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import { type HysTreeKey } from "./tree";
+import type { Placement } from "./useFloating";
+export type HysCascaderKey = HysTreeKey;
+export type HysCascaderPath = readonly HysCascaderKey[];
+export type HysCascaderValue = HysCascaderKey | HysCascaderPath | readonly HysCascaderPath[] | null;
+export interface HysCascaderDataNode<K extends HysCascaderKey = HysCascaderKey> {
+    label: string;
+    value: K;
+    children?: HysCascaderDataNode<K>[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+    hasChildren?: boolean;
+}
+/** Original string-valued data shape remains available. */
+export type HysCascaderNode = HysCascaderDataNode<string>;
+export interface HysCascaderFieldNames {
+    value: string;
+    label: string;
+    children: string;
+    disabled: string;
+    leaf: string;
+    hasChildren: string;
+}
+export interface HysCascaderItem<N extends object = HysCascaderNode> {
+    path: HysCascaderKey[];
+    labels: string[];
+    nodes: N[];
+    node?: N;
+    value: HysCascaderKey;
+    label: string;
+    disabled: boolean;
+    missing: boolean;
+}
+export interface HysCascaderOptionContext<N extends object = HysCascaderNode> extends HysCascaderItem<N> {
+    node: N;
+    level: number;
+    leaf: boolean;
+    expanded: boolean;
+    checked: boolean;
+    indeterminate: boolean;
+    loading: boolean;
+}
+export interface HysCascaderLoadContext<N extends object = HysCascaderNode> {
+    signal: AbortSignal;
+    path: HysCascaderKey[];
+    nodes: N[];
+    level: number;
+}
+export interface HysCascaderChange<N extends object = HysCascaderNode> {
+    reason: "select" | "check" | "remove" | "clear" | "api";
+    node?: N;
+    items: HysCascaderItem<N>[];
+    paths: HysCascaderKey[][];
+    halfCheckedPaths: HysCascaderKey[][];
+    event?: Event;
+}
+export interface HysCascaderLocale {
+    panel: string;
+    search: string;
+    empty: string;
+    noMatch: string;
+    loading: string;
+    loadError: string;
+    retry: string;
+    clear: string;
+    close: string;
+    level: string;
+    expand: string;
+    remove: string;
+    more: string;
+    limit: string;
+}
+export interface HysCascaderProps<N extends object = HysCascaderNode, V extends HysCascaderValue = HysCascaderValue> {
+    options: readonly N[];
+    modelValue?: V;
+    defaultValue?: V;
+    cacheData?: readonly N[];
+    fieldNames?: Partial<HysCascaderFieldNames>;
+    valueKey?: string | ((node: N) => HysCascaderKey);
+    disabledMethod?: (node: N, path: readonly N[]) => boolean;
+    leafMethod?: (node: N, path: readonly N[]) => boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+    status?: "error" | "warning" | "success";
+    placeholder?: string;
+    ariaLabel?: string;
+    name?: string;
+    form?: string;
+    autofocus?: boolean;
+    multiple?: boolean;
+    emitPath?: boolean;
+    checkStrictly?: boolean;
+    changeOnSelect?: boolean;
+    showCheckedStrategy?: "child" | "parent" | "all";
+    checkOnClickNode?: boolean;
+    checkOnClickLeaf?: boolean;
+    showPrefix?: boolean;
+    showAllLevels?: boolean;
+    separator?: string;
+    displayRender?: (item: HysCascaderItem<N>) => VNodeChild;
+    clearable?: boolean;
+    clearValue?: HysCascaderValue;
+    removable?: boolean;
+    multipleLimit?: number;
+    maxTagCount?: number;
+    maxTagTextLength?: number;
+    filterable?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    searchPlaceholder?: string;
+    filterMethod?: (query: string, path: readonly N[]) => boolean;
+    searchSort?: (a: HysCascaderItem<N>, b: HysCascaderItem<N>, query: string) => number;
+    searchLimit?: number | false;
+    debounce?: number;
+    beforeFilter?: (query: string, context: {
+        signal: AbortSignal;
+    }) => boolean | Promise<boolean>;
+    retainSearch?: boolean;
+    clearSearchAfterSelect?: boolean;
+    expandTrigger?: "click" | "hover";
+    hoverDelay?: number;
+    expandedPath?: HysCascaderPath;
+    defaultExpandedPath?: HysCascaderPath;
+    loadChildren?: (node: N, context: HysCascaderLoadContext<N>) => Promise<readonly N[]>;
+    loadRoot?: (context: {
+        signal: AbortSignal;
+    }) => Promise<readonly N[]>;
+    inline?: boolean;
+    showFooter?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    showOnFocus?: boolean;
+    popupMatchWidth?: boolean;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    appendTo?: string | HTMLElement | false;
+    placement?: Placement;
+    columnWidth?: number | string;
+    listHeight?: number;
+    virtual?: boolean;
+    itemHeight?: number;
+    overscan?: number;
+    emptyText?: string;
+    noMatchText?: string;
+    loadingText?: string;
+    locale?: Partial<HysCascaderLocale>;
+    validateEvent?: boolean;
+}
+export interface HysCascaderInstance<N extends object = HysCascaderNode> {
+    readonly element: HTMLElement | undefined;
+    readonly open: boolean;
+    focus: () => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: (restoreFocus?: boolean) => void;
+    clear: () => Promise<boolean>;
+    clearCheckedNodes: () => Promise<boolean>;
+    removeTag: (path: HysCascaderPath | HysCascaderKey) => Promise<boolean>;
+    setValue: (value: HysCascaderValue) => Promise<boolean>;
+    filter: (query: string) => void;
+    getSelectedItems: () => HysCascaderItem<N>[];
+    getCheckedNodes: (leafOnly?: boolean) => N[];
+    getExpandedPath: () => HysCascaderKey[];
+    setExpandedPath: (path: HysCascaderPath) => Promise<boolean>;
+    reloadNode: (path: HysCascaderPath) => Promise<boolean>;
+    reloadRoot: () => Promise<boolean>;
+    scrollTo: (path: HysCascaderPath) => Promise<void>;
+}
+export interface CascaderEntry<N extends object> {
+    value: string;
+    label: string;
+    raw: N;
+    path: HysCascaderKey[];
+    labels: string[];
+    nodes: N[];
+    children?: CascaderEntry<N>[];
+    disabled: boolean;
+    isLeaf: boolean;
+    hasChildren: boolean;
+}
+export declare const cascaderToken: (path: HysCascaderPath) => string;
+export declare function cascaderPath(token: string): HysCascaderKey[];
+export declare const validCascaderPath: (path: unknown) => path is HysCascaderKey[];
+export declare const cascaderWords: HysCascaderLocale;
+export declare function cascaderEntries<N extends object>(options: readonly N[], props: HysCascaderProps<N>, parent?: CascaderEntry<N>): {
+    roots: CascaderEntry<N>[];
+    map: Map<string, CascaderEntry<N>>;
+};

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

@@ -0,0 +1,110 @@
+import type { ComputedRef, InjectionKey, Ref } from "vue";
+export type HysChoiceValue = string | number | boolean;
+export interface HysChoiceFieldNames {
+    label?: string;
+    value?: string;
+    disabled?: string;
+    indeterminate?: string;
+}
+export interface HysChoiceOption<T extends HysChoiceValue = HysChoiceValue> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    [key: string]: unknown;
+}
+export type HysChoiceDataOption<T extends HysChoiceValue = HysChoiceValue> = T | HysChoiceOption<T> | Record<string, unknown>;
+export interface HysCheckboxReject {
+    value?: HysChoiceValue;
+    checked?: boolean;
+    reason: "min" | "max" | "range";
+}
+export interface HysCheckboxChange {
+    value?: HysChoiceValue;
+    checked?: boolean;
+    source: "toggle" | "all" | "clear";
+}
+export interface HysCheckboxInstance {
+    input: HTMLInputElement | undefined;
+    checked: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    toggle: () => Promise<boolean>;
+}
+export interface HysCheckboxGroupInstance {
+    values: HysChoiceValue[];
+    allChecked: boolean;
+    indeterminate: boolean;
+    focus: (value?: HysChoiceValue) => void;
+    blur: () => void;
+    checkAll: () => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    toggle: (value: HysChoiceValue, checked?: boolean) => Promise<boolean>;
+}
+interface CheckboxRegistration {
+    input: Ref<HTMLInputElement | undefined>;
+    value: ComputedRef<HysChoiceValue | undefined>;
+    locked: ComputedRef<boolean>;
+    disabled: ComputedRef<boolean>;
+}
+export interface HysCheckboxGroupContext {
+    values: ComputedRef<HysChoiceValue[]>;
+    disabled: ComputedRef<boolean>;
+    readonly: ComputedRef<boolean>;
+    size: ComputedRef<"sm" | "md" | "lg">;
+    button: ComputedRef<boolean>;
+    border: ComputedRef<boolean>;
+    solid: ComputedRef<boolean>;
+    status: ComputedRef<string | undefined>;
+    form: ComputedRef<string | undefined>;
+    isLimited: (value: HysChoiceValue) => boolean;
+    toggle: (value: HysChoiceValue, checked: boolean) => Promise<boolean>;
+    register: (record: CheckboxRegistration) => () => void;
+}
+export declare const checkboxGroupKey: InjectionKey<HysCheckboxGroupContext>;
+export declare function isChoice(value: unknown): value is HysChoiceValue;
+export declare function choiceKey(value: HysChoiceValue): string;
+export declare function uniqueChoices(values: readonly unknown[]): HysChoiceValue[];
+export declare function choiceOptions<T extends HysChoiceValue>(source: readonly HysChoiceDataOption<T>[], fields?: HysChoiceFieldNames): HysChoiceOption<T>[];
+export interface HysRadioInstance {
+    input: HTMLInputElement | undefined;
+    checked: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    select: () => Promise<boolean>;
+}
+export interface HysRadioGroupInstance {
+    value: HysChoiceValue | null;
+    focus: (value?: HysChoiceValue) => void;
+    blur: () => void;
+    select: (value: HysChoiceValue) => Promise<boolean>;
+}
+export interface HysRadioGroupContext {
+    value: ComputedRef<HysChoiceValue | null>;
+    disabled: ComputedRef<boolean>;
+    readonly: ComputedRef<boolean>;
+    required: ComputedRef<boolean>;
+    size: ComputedRef<"sm" | "md" | "lg">;
+    button: ComputedRef<boolean>;
+    border: ComputedRef<boolean>;
+    solid: ComputedRef<boolean>;
+    name: ComputedRef<string>;
+    form: ComputedRef<string | undefined>;
+    status: ComputedRef<string | undefined>;
+    select: (value: HysChoiceValue) => Promise<boolean>;
+    tabindex: (value: HysChoiceValue) => number;
+    register: (record: CheckboxRegistration) => () => void;
+}
+export declare const radioGroupKey: InjectionKey<HysRadioGroupContext>;
+export interface HysSwitchGuardContext {
+    signal: AbortSignal;
+}
+export interface HysSwitchInstance {
+    element: HTMLButtonElement | undefined;
+    checked: boolean;
+    pending: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    toggle: () => Promise<boolean>;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { type Ref } from "vue";
+export declare function useChoiceModel<V>(props: {
+    modelValue?: V;
+}, initial: () => V, equal?: (a: V, b: V) => boolean, invalidated?: () => void): {
+    current: import("vue").ComputedRef<V>;
+    commit: (value: V, update: (value: V) => void, change: (value: V) => void, notifyOnRequest?: boolean) => Promise<boolean>;
+    reset: () => void;
+    invalidate: () => void;
+    isLive: () => boolean;
+};
+export declare function useChoiceNativeReset(element: Ref<HTMLElement | undefined>, reset: () => void, sync?: () => void, formId?: () => string | undefined): void;

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

@@ -0,0 +1,247 @@
+import type { CSSProperties } from "vue";
+import type { Placement } from "./useFloating";
+export type HysDateScalar = string | Date | number;
+export type HysDatePickerValue = HysDateScalar | readonly (HysDateScalar | null)[] | null;
+export type HysDateRangeValue = readonly [HysDateScalar | null, HysDateScalar | null] | null;
+export type HysDatePickerType = "date" | "dates" | "week" | "weeks" | "month" | "months" | "quarter" | "quarters" | "year" | "years" | "datetime";
+export type HysDatePickerView = "date" | "month" | "quarter" | "year";
+export type HysDatePickerUnit = "date" | "week" | "month" | "quarter" | "year";
+export interface HysDatePoint {
+    day: number;
+    second: number;
+}
+export interface HysDatePickerContext {
+    range: "start" | "end";
+    from: Date | null;
+    iso: string;
+}
+export interface HysDateDisabledTime {
+    hours?: readonly number[];
+    minutes?: (hour: number) => readonly number[];
+    seconds?: (hour: number, minute: number) => readonly number[];
+}
+export interface HysDateShortcut {
+    label: string;
+    value: HysDatePickerValue | (() => HysDatePickerValue);
+    disabled?: boolean;
+}
+export interface HysDatePickerCell {
+    date: Date;
+    iso: string;
+    value: number;
+    end: number;
+    text: string;
+    type: HysDatePickerView;
+    outside: boolean;
+    disabled: boolean;
+    selected: boolean;
+    inRange: boolean;
+    today: boolean;
+    week: number;
+    weekYear: number;
+    weekStart: string;
+    weekEnd: string;
+}
+export interface HysDatePickerWeek {
+    year: number;
+    week: number;
+    start: string;
+    end: string;
+    dates: readonly string[];
+}
+export interface HysDatePickerChange {
+    source: "date" | "time" | "input" | "shortcut" | "clear" | "confirm" | "api";
+    dates: readonly (Date | null)[];
+    formatted: readonly string[];
+    weeks?: readonly (HysDatePickerWeek | null)[];
+}
+export interface HysDatePickerLocale {
+    today: string;
+    now: string;
+    clear: string;
+    cancel: string;
+    close: string;
+    confirm: string;
+    start: string;
+    end: string;
+    chooseStart: string;
+    chooseEnd: string;
+    invalid: string;
+    week: string;
+    year: string;
+    month: string;
+    back: string;
+    prevMonth: string;
+    nextMonth: string;
+    prevYear: string;
+    nextYear: string;
+    hour: string;
+    minute: string;
+    second: string;
+    empty: string;
+    limit: string;
+}
+export interface HysDatePickerProps<V extends HysDatePickerValue = HysDatePickerValue> {
+    modelValue?: V;
+    defaultValue?: V;
+    clearValue?: V;
+    type?: HysDatePickerType;
+    valueType?: "string" | "date" | "timestamp";
+    valueFormat?: string;
+    format?: string;
+    inputFormats?: readonly string[];
+    disabled?: boolean | readonly [boolean, boolean];
+    readonly?: boolean;
+    size?: "sm" | "md" | "lg";
+    status?: "error" | "warning" | "success";
+    bordered?: boolean;
+    placeholder?: string;
+    label?: string;
+    ariaLabel?: string;
+    name?: string | readonly [string, string];
+    form?: string;
+    autofocus?: boolean;
+    min?: HysDateScalar;
+    max?: HysDateScalar;
+    disabledDate?: (date: Date, context: HysDatePickerContext) => boolean;
+    disabledTime?: (date: Date, context: HysDatePickerContext) => HysDateDisabledTime;
+    firstDayOfWeek?: number;
+    firstWeekContainsDate?: number;
+    weekNumberFormatter?: (week: HysDatePickerWeek) => string;
+    disabledWeek?: (week: HysDatePickerWeek) => boolean;
+    weekValidation?: "any" | "full";
+    locale?: string;
+    messages?: Partial<HysDatePickerLocale>;
+    showWeekNumbers?: boolean;
+    showAdjacentDays?: boolean;
+    defaultPickerValue?: HysDateScalar;
+    panelValue?: HysDateScalar;
+    mode?: HysDatePickerView;
+    defaultMode?: HysDatePickerView;
+    shortcuts?: readonly HysDateShortcut[];
+    clearable?: boolean;
+    editable?: boolean;
+    inputReadonly?: boolean;
+    showOnFocus?: boolean;
+    showToday?: boolean;
+    showNow?: boolean;
+    showFooter?: boolean;
+    showConfirm?: boolean;
+    showTime?: boolean;
+    defaultTime?: string | readonly [string, string];
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    showSeconds?: boolean;
+    rangeSeparator?: string;
+    startPlaceholder?: string;
+    endPlaceholder?: string;
+    allowEmpty?: readonly [boolean, boolean];
+    singlePanel?: boolean;
+    unlinkPanels?: boolean;
+    minRangeDays?: number;
+    maxRangeDays?: number;
+    rangeValidation?: "endpoints" | "continuous";
+    maxDates?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    inline?: boolean;
+    placement?: Placement;
+    appendTo?: string | HTMLElement | false;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    validateEvent?: boolean;
+    cellClassName?: (cell: HysDatePickerCell) => string;
+}
+export interface HysDateRangePickerProps<V extends HysDatePickerValue = HysDateRangeValue> extends HysDatePickerProps<V> {
+}
+export interface HysDatePickerInstance<V extends HysDatePickerValue = HysDatePickerValue> {
+    readonly element: HTMLElement | undefined;
+    readonly open: boolean;
+    readonly value: V;
+    readonly draft: readonly (Date | null)[];
+    focus: () => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: (restoreFocus?: boolean) => void;
+    handleOpen: () => Promise<boolean>;
+    handleClose: () => void;
+    clear: () => Promise<boolean>;
+    setValue: (value: V) => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    cancel: () => void;
+    showMonth: (value: HysDateScalar) => Promise<boolean>;
+    setMode: (view: HysDatePickerView) => boolean;
+}
+export interface HysDatePickerSlots {
+    "week-number"?: (week: HysDatePickerWeek & {
+        selected: boolean;
+        disabled: boolean;
+    }) => any;
+    default?: (cell: HysDatePickerCell) => any;
+    cell?: (cell: HysDatePickerCell) => any;
+    prefix?: () => any;
+    suffix?: () => any;
+    "clear-icon"?: () => any;
+    "prev-month"?: () => any;
+    "next-month"?: () => any;
+    "prev-year"?: () => any;
+    "next-year"?: () => any;
+    header?: (context: {
+        dates: readonly (Date | null)[];
+        view: HysDatePickerView;
+    }) => any;
+    footer?: (context: {
+        dates: readonly (Date | null)[];
+        confirm: () => Promise<boolean>;
+        cancel: () => void;
+        clear: () => Promise<boolean>;
+    }) => any;
+    shortcut?: (context: {
+        shortcut: HysDateShortcut;
+        index: number;
+    }) => any;
+    "range-separator"?: () => any;
+}
+export type HysDateRangePickerInstance<V extends HysDatePickerValue = HysDateRangeValue> = HysDatePickerInstance<V>;
+export declare const datePickerDefaults: {
+    readonly open: undefined;
+    readonly showConfirm: undefined;
+    readonly type: "date";
+    readonly clearable: false;
+    readonly editable: false;
+    readonly bordered: true;
+    readonly firstDayOfWeek: 1;
+    readonly locale: "zh-CN";
+    readonly showAdjacentDays: true;
+    readonly showToday: true;
+    readonly showNow: true;
+    readonly showFooter: true;
+    readonly showSeconds: true;
+    readonly singlePanel: true;
+    readonly rangeSeparator: " 至 ";
+    readonly hourStep: 1;
+    readonly minuteStep: 1;
+    readonly secondStep: 1;
+    readonly rangeValidation: "endpoints";
+    readonly validateEvent: true;
+    readonly appendTo: "body";
+};
+export declare const datePickerWords: HysDatePickerLocale;
+export declare const datePickerEnglish: HysDatePickerLocale;
+export declare const DATE_MIN: number, DATE_MAX: number;
+export declare const dateUnit: (type: string | undefined) => HysDatePickerUnit;
+export declare const dateMultiple: (type: string | undefined) => boolean;
+export declare function datePattern(type: string | undefined, time?: boolean): "YYYY-MM-DD" | "YYYY" | "YYYY-MM-DD HH:mm:ss" | "YYYY-MM" | "YYYY-[Q]Q";
+export declare function datePeriod(day: number, unit: HysDatePickerUnit, first?: number): [number, number];
+export declare function dateTimeString(second: number): string;
+export declare function dateTimeSeconds(value: string | undefined): number;
+export declare function dateWeek(day: number, first?: number, contains?: number): HysDatePickerWeek;
+export declare function dateFormat(point: HysDatePoint, pattern: string, first?: number, contains?: number): string;
+export declare function datePoint(value: unknown, pattern?: string, first?: number, contains?: number): HysDatePoint | undefined;
+export declare function dateNative(point: HysDatePoint): Date;
+export declare function dateEqual(a: HysDatePickerValue | undefined, b: HysDatePickerValue | undefined): boolean;
+export declare function dateClone<V extends HysDatePickerValue>(value: V): V;
+export declare function dateLocale(locale: string): Intl.DateTimeFormat;
+export declare function dateShift(day: number, months: number): number;