@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/select/SelectOptionGroup.vue.d.ts

@@ -0,0 +1,14 @@
+import { SelectOptionGroupProps } from './types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<SelectOptionGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SelectOptionGroupProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/select/index.d.ts

@@ -0,0 +1,12 @@
+import { DefineComponent } from 'vue';
+import { default as SelectOption } from './SelectOption.vue';
+import { default as SelectOptionGroup } from './SelectOptionGroup.vue';
+import { SelectOptionGroupProps, SelectOptionProps, SelectProps } from './types';
+export type SelectCompoundComponent = DefineComponent<SelectProps> & {
+    Option: DefineComponent<SelectOptionProps>;
+    OptGroup: DefineComponent<SelectOptionGroupProps>;
+};
+declare const SelectWithChildren: SelectCompoundComponent;
+export { SelectWithChildren as Select, SelectOption, SelectOptionGroup };
+export type { SelectEmits, SelectExposed, SelectInputProps, SelectModelValue, SelectOptionGroupProps, SelectOptionProps, SelectOptionRenderProps, SelectPrimitive, SelectProps, SelectSearchPosition, SelectSize, SelectSlots, SelectTriggerSlotProps, SelectValidateStatus, SelectValue, SelectVirtualizeProps, } from './types';
+export default SelectWithChildren;

package/dist/select/index.js

@@ -0,0 +1,3 @@
+import { t as e } from "../SelectOption-Ce-Lst-e.js";
+import { n as t, t as n } from "../select-BeM6gxAU.js";
+export { n as Select, n as default, e as SelectOption, t as SelectOptionGroup };

package/dist/select/types.d.ts

@@ -0,0 +1,165 @@
+import { HTMLAttributes, InputHTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { TooltipMargin, TooltipPosition, TooltipProps, TooltipSpacing } from '../tooltip';
+export type SelectPrimitive = string | number;
+export type SelectValue = SelectPrimitive | Record<string, unknown>;
+export type SelectModelValue = SelectValue | SelectValue[] | undefined;
+export type SelectSize = 'small' | 'default' | 'large';
+export type SelectSearchPosition = 'trigger' | 'dropdown';
+export type SelectValidateStatus = 'default' | 'warning' | 'error';
+export interface SelectOptionProps {
+    value?: SelectPrimitive;
+    label?: VNodeChild;
+    disabled?: boolean;
+    showTick?: boolean;
+    class?: HTMLAttributes['class'];
+    style?: StyleValue;
+    [key: string]: unknown;
+}
+export interface SelectOptionRuntime extends SelectOptionProps {
+    _key?: PropertyKey;
+    _parentGroup?: SelectOptionGroupRuntime;
+    _scrollIndex: number;
+    _selected: boolean;
+    _show: boolean;
+    _inputCreateOnly?: boolean;
+    children?: VNodeChild;
+}
+export interface SelectOptionGroupProps {
+    label?: VNodeChild;
+    class?: HTMLAttributes['class'];
+    style?: StyleValue;
+}
+export interface SelectOptionGroupRuntime extends SelectOptionGroupProps {
+    _key?: PropertyKey;
+}
+export interface SelectVirtualizeProps {
+    itemSize?: number;
+    height?: number;
+    width?: string | number;
+}
+export interface SelectInputProps extends Omit<InputHTMLAttributes, 'value' | 'onInput'> {
+    class?: HTMLAttributes['class'];
+}
+export interface SelectProps {
+    ariaDescribedby?: string;
+    ariaErrormessage?: string;
+    ariaInvalid?: boolean | 'false' | 'true' | 'grammar' | 'spelling';
+    ariaLabelledby?: string;
+    ariaRequired?: boolean;
+    id?: string;
+    autoFocus?: boolean;
+    autoClearSearchValue?: boolean;
+    autoAdjustOverflow?: boolean;
+    allowCreate?: boolean;
+    borderless?: boolean;
+    clickToHide?: boolean;
+    defaultActiveFirstOption?: boolean;
+    defaultOpen?: boolean;
+    defaultValue?: SelectModelValue;
+    disabled?: boolean;
+    dropdownClassName?: HTMLAttributes['class'];
+    dropdownMargin?: number | TooltipMargin;
+    dropdownMatchSelectWidth?: boolean;
+    dropdownStyle?: StyleValue;
+    ellipsisTrigger?: boolean;
+    emptyContent?: VNodeChild | null;
+    expandRestTagsOnClick?: boolean;
+    filter?: boolean | ((inputValue: string, option: SelectOptionProps) => boolean);
+    getPopupContainer?: () => HTMLElement;
+    inputProps?: SelectInputProps;
+    insetLabelId?: string;
+    loading?: boolean;
+    max?: number;
+    maxHeight?: string | number;
+    maxTagCount?: number;
+    modelValue?: SelectModelValue;
+    motion?: boolean;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    multiple?: boolean;
+    onChangeWithObject?: boolean;
+    optionList?: SelectOptionProps[];
+    placeholder?: VNodeChild;
+    position?: TooltipPosition;
+    preventScroll?: boolean;
+    rePosKey?: string | number;
+    restTagsPopoverProps?: Partial<TooltipProps>;
+    remote?: boolean;
+    searchPlaceholder?: string;
+    searchPosition?: SelectSearchPosition;
+    showArrow?: boolean;
+    showClear?: boolean;
+    showRestTagsPopover?: boolean;
+    size?: SelectSize;
+    spacing?: number | TooltipSpacing;
+    stopPropagation?: boolean;
+    validateStatus?: SelectValidateStatus;
+    value?: SelectModelValue;
+    virtualize?: SelectVirtualizeProps;
+    zIndex?: number;
+}
+export interface SelectEmits {
+    blur: [event: FocusEvent];
+    change: [value: SelectModelValue];
+    clear: [];
+    create: [option: SelectOptionProps];
+    deselect: [value: SelectPrimitive | undefined, option: SelectOptionProps];
+    dropdownVisibleChange: [visible: boolean];
+    exceed: [option: SelectOptionProps];
+    focus: [event: FocusEvent];
+    listScroll: [event: Event];
+    search: [value: string, event?: Event];
+    select: [value: SelectPrimitive | undefined, option: SelectOptionProps];
+    'update:modelValue': [value: SelectModelValue];
+    'update:value': [value: SelectModelValue];
+}
+export interface SelectSlots {
+    default?: () => VNodeChild;
+    arrowIcon?: () => VNodeChild;
+    clearIcon?: () => VNodeChild;
+    createItem?: (props: {
+        inputValue: SelectPrimitive;
+        focused: boolean;
+        style?: StyleValue;
+    }) => VNodeChild;
+    emptyContent?: () => VNodeChild;
+    innerBottom?: () => VNodeChild;
+    innerTop?: () => VNodeChild;
+    insetLabel?: () => VNodeChild;
+    option?: (props: SelectOptionRenderProps) => VNodeChild;
+    outerBottom?: () => VNodeChild;
+    outerTop?: () => VNodeChild;
+    prefix?: () => VNodeChild;
+    selectedItem?: (props: {
+        option: SelectOptionRuntime;
+        index: number;
+    }) => VNodeChild;
+    suffix?: () => VNodeChild;
+    trigger?: (props: SelectTriggerSlotProps) => VNodeChild;
+}
+export interface SelectOptionRenderProps extends SelectOptionRuntime {
+    focused: boolean;
+    selected: boolean;
+    inputValue: string;
+    onClick: (event: MouseEvent) => void;
+    onMouseenter: (event: MouseEvent) => void;
+}
+export interface SelectTriggerSlotProps {
+    value: SelectOptionRuntime[];
+    inputValue: string;
+    disabled: boolean;
+    placeholder: VNodeChild;
+    onSearch: (value: string, event?: Event) => void;
+    onClear: (event: MouseEvent) => void;
+    onRemove: (option: SelectOptionRuntime) => void;
+}
+export interface SelectExposed {
+    clearInput(): void;
+    close(): void;
+    deselectAll(): void;
+    focus(): void;
+    open(): void;
+    rePosition(): void;
+    search(value: string, event?: Event): void;
+    selectAll(): void;
+}

package/dist/select/use-select-foundation.d.ts

@@ -0,0 +1,64 @@
+import { ComputedRef, Ref } from 'vue';
+import { SelectEmits, SelectOptionRuntime, SelectProps } from './types';
+export interface SelectState {
+    isOpen: boolean;
+    isFocus: boolean;
+    options: SelectOptionRuntime[];
+    selections: Map<unknown, SelectOptionRuntime>;
+    dropdownMinWidth: number | string | undefined;
+    optionKey: number;
+    inputValue: string;
+    showInput: boolean;
+    focusIndex: number;
+    keyboardEventSet: Record<string, (event: KeyboardEvent) => void>;
+    optionGroups: unknown[];
+    isHovering: boolean;
+    isFocusInContainer: boolean;
+    isFullTags: boolean;
+    overflowItemCount: number;
+}
+interface SelectFoundationController {
+    _handleKeyDown(event: KeyboardEvent): void;
+    clearInput(event?: Event): void;
+    clearSelected(): void;
+    close(config?: {
+        event?: Event;
+        closeCb?: () => void;
+        notToggleInput?: boolean;
+    }): void;
+    focus(options?: unknown[], openDropdown?: boolean): void;
+    handleClearClick(event: Event): void;
+    handleClick(event: Event): void;
+    handleContainerKeyDown(event: KeyboardEvent): void;
+    handleInputBlur(event: FocusEvent): void;
+    handleInputChange(value: string, event?: Event): void;
+    handleListScroll(event: Event): void;
+    handleMouseEnter(event: MouseEvent): void;
+    handleMouseLeave(event: MouseEvent): void;
+    handleOptionListChange(): void;
+    handleOptionListChangeHadDefaultValue(): void;
+    handleOptionMouseEnter(index: number): void;
+    handlePopoverClose(): void;
+    handleSlotMouseEnter(): void;
+    handleTriggerBlur(event: FocusEvent): void;
+    handleTriggerFocus(event: FocusEvent): void;
+    onSelect(option: SelectOptionRuntime, index: number, event: Event): void;
+    open(input?: string): void;
+    removeTag(option: SelectOptionRuntime): void;
+    selectAll(): void;
+}
+interface SelectFoundationBinding {
+    foundation: SelectFoundationController;
+    state: SelectState;
+}
+interface UseSelectFoundationOptions {
+    controlled: ComputedRef<boolean>;
+    emit: <K extends keyof SelectEmits>(event: K, ...args: SelectEmits[K]) => void;
+    getOptions: () => SelectOptionRuntime[];
+    listElement: Ref<HTMLDivElement | null>;
+    runtimeProps: ComputedRef<SelectRuntimeProps>;
+    triggerElement: Ref<HTMLDivElement | null>;
+}
+export type SelectRuntimeProps = Omit<SelectProps, 'autoAdjustOverflow' | 'autoClearSearchValue' | 'allowCreate' | 'borderless' | 'defaultActiveFirstOption' | 'defaultOpen' | 'disabled' | 'dropdownMatchSelectWidth' | 'filter' | 'maxHeight' | 'motion' | 'multiple' | 'onChangeWithObject' | 'placeholder' | 'remote' | 'searchPosition' | 'showArrow' | 'showClear' | 'showRestTagsPopover' | 'size' | 'stopPropagation' | 'validateStatus' | 'zIndex'> & Required<Pick<SelectProps, 'autoAdjustOverflow' | 'autoClearSearchValue' | 'allowCreate' | 'borderless' | 'defaultActiveFirstOption' | 'defaultOpen' | 'disabled' | 'dropdownMatchSelectWidth' | 'filter' | 'maxHeight' | 'motion' | 'multiple' | 'onChangeWithObject' | 'placeholder' | 'remote' | 'searchPosition' | 'showArrow' | 'showClear' | 'showRestTagsPopover' | 'size' | 'stopPropagation' | 'validateStatus' | 'zIndex'>>;
+export declare function useSelectFoundation(options: UseSelectFoundationOptions): SelectFoundationBinding;
+export {};

package/dist/select-BeM6gxAU.js

@@ -0,0 +1,40 @@
+import { n as e, t } from "./SelectOption-Ce-Lst-e.js";
+import { defineComponent as n, renderSlot as r } from "vue";
+//#endregion
+//#region src/select/SelectOptionGroup.vue
+var i = /* @__PURE__ */ n({
+	name: "SelectOptionGroup",
+	__name: "SelectOptionGroup",
+	props: {
+		label: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array
+		] },
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		return (e, t) => r(e.$slots, "default");
+	}
+}), a = Object.assign(e, {
+	Option: t,
+	OptGroup: i
+});
+//#endregion
+export { i as n, a as t };

package/dist/side-sheet/SideSheet.vue.d.ts

@@ -0,0 +1,19 @@
+import { SideSheetProps, SideSheetSlots } from './types';
+type __VLS_Slots = SideSheetSlots;
+declare const __VLS_base: import('vue').DefineComponent<SideSheetProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: (event: import('./types').SideSheetCancelEvent) => any;
+    "update:visible": (visible: boolean) => any;
+    afterVisibleChange: (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<SideSheetProps> & Readonly<{
+    onCancel?: (event: import('./types').SideSheetCancelEvent) => any;
+    "onUpdate:visible"?: (visible: boolean) => any;
+    onAfterVisibleChange?: (visible: boolean) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/side-sheet/SideSheetContent.vue.d.ts

@@ -0,0 +1,37 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { SideSheetCancelEvent, SideSheetPlacement, SideSheetSize } from './types';
+interface Props {
+    ariaLabel?: string | undefined;
+    body: VNodeChild;
+    bodyStyle?: StyleValue | undefined;
+    class?: HTMLAttributes['class'];
+    closable: boolean;
+    closeIcon: VNodeChild;
+    customContainer: boolean;
+    dataAttrs: Record<string, unknown>;
+    dialogClass?: HTMLAttributes['class'];
+    footer: VNodeChild;
+    headerStyle?: StyleValue | undefined;
+    height: number | string;
+    hidden: boolean;
+    mask: boolean;
+    maskClass?: HTMLAttributes['class'];
+    maskClosable: boolean;
+    maskStyle?: StyleValue | undefined;
+    outerStyle?: StyleValue | undefined;
+    placement: SideSheetPlacement;
+    rtl: boolean;
+    size: SideSheetSize;
+    title: VNodeChild;
+    width?: number | string | undefined;
+    wrapperWidth?: number | string | undefined;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (event: SideSheetCancelEvent) => any;
+    animationEnd: (event: AnimationEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClose?: (event: SideSheetCancelEvent) => any;
+    onAnimationEnd?: (event: AnimationEvent) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/side-sheet/SideSheetNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/side-sheet/index.d.ts

@@ -0,0 +1,4 @@
+import { default as SideSheet } from './SideSheet.vue';
+export { SideSheet };
+export default SideSheet;
+export { SIDE_SHEET_PLACEMENTS, SIDE_SHEET_SIZES, type SideSheetCancelEvent, type SideSheetEmits, type SideSheetPlacement, type SideSheetProps, type SideSheetSize, type SideSheetSlots, } from './types';

package/dist/side-sheet/index.js

@@ -0,0 +1,2 @@
+import { i as e, n as t, r as n, t as r } from "../side-sheet-9CBTk23r.js";
+export { t as SIDE_SHEET_PLACEMENTS, n as SIDE_SHEET_SIZES, e as SideSheet, r as default };

package/dist/side-sheet/types.d.ts

@@ -0,0 +1,46 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const SIDE_SHEET_PLACEMENTS: readonly ["top", "right", "bottom", "left"];
+export declare const SIDE_SHEET_SIZES: readonly ["small", "medium", "large"];
+export type SideSheetPlacement = (typeof SIDE_SHEET_PLACEMENTS)[number];
+export type SideSheetSize = (typeof SIDE_SHEET_SIZES)[number];
+export type SideSheetCancelEvent = MouseEvent | KeyboardEvent;
+export interface SideSheetProps {
+    'aria-label'?: string;
+    afterVisibleChange?: (visible: boolean) => void;
+    bodyStyle?: StyleValue;
+    canVerticalSetWidth?: boolean;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    closable?: boolean;
+    closeIcon?: VNodeChild;
+    closeOnEsc?: boolean;
+    disableScroll?: boolean;
+    footer?: VNodeChild;
+    getPopupContainer?: () => HTMLElement;
+    headerStyle?: StyleValue;
+    height?: number | string;
+    keepDOM?: boolean;
+    mask?: boolean;
+    maskClosable?: boolean;
+    maskStyle?: StyleValue;
+    motion?: boolean;
+    onCancel?: (event: SideSheetCancelEvent) => void;
+    placement?: SideSheetPlacement;
+    size?: SideSheetSize;
+    style?: StyleValue;
+    title?: VNodeChild;
+    visible?: boolean;
+    width?: number | string;
+    zIndex?: number;
+}
+export interface SideSheetEmits {
+    afterVisibleChange: [visible: boolean];
+    cancel: [event: SideSheetCancelEvent];
+    'update:visible': [visible: boolean];
+}
+export interface SideSheetSlots {
+    closeIcon?: () => VNodeChild;
+    default?: () => VNodeChild;
+    footer?: () => VNodeChild;
+    title?: () => VNodeChild;
+}