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

package/dist/tooltip/types.d.ts

@@ -0,0 +1,117 @@
+import { ComponentPublicInstance, HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const TOOLTIP_POSITIONS: readonly ["top", "topLeft", "topRight", "left", "leftTop", "leftBottom", "right", "rightTop", "rightBottom", "bottom", "bottomLeft", "bottomRight", "leftTopOver", "rightTopOver", "leftBottomOver", "rightBottomOver"];
+export declare const TOOLTIP_TRIGGERS: readonly ["hover", "focus", "click", "custom", "contextMenu"];
+export type TooltipPosition = (typeof TOOLTIP_POSITIONS)[number];
+export type TooltipTrigger = (typeof TOOLTIP_TRIGGERS)[number];
+export interface TooltipArrowBounding {
+    offsetX?: number;
+    offsetY?: number;
+    width?: number;
+    height?: number;
+}
+export interface TooltipSpacing {
+    x: number;
+    y: number;
+}
+export interface TooltipMargin {
+    marginLeft: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+}
+export type TooltipInitialFocusRef = (element: Element | ComponentPublicInstance | null) => void;
+export interface TooltipProps {
+    arrowBounding?: TooltipArrowBounding;
+    arrowPointAtCenter?: boolean;
+    autoAdjustOverflow?: boolean;
+    class?: HTMLAttributes['class'];
+    clickToHide?: boolean;
+    clickTriggerToHide?: boolean;
+    closeOnEsc?: boolean;
+    condition?: boolean;
+    content?: VNodeChild;
+    disableArrowKeyDown?: boolean;
+    disableFocusListener?: boolean;
+    getPopupContainer?: () => HTMLElement;
+    guardFocus?: boolean;
+    keepDOM?: boolean;
+    margin?: number | TooltipMargin;
+    motion?: boolean;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    position?: TooltipPosition;
+    prefixCls?: string;
+    preventScroll?: boolean;
+    rePosKey?: string | number;
+    returnFocusOnClose?: boolean;
+    role?: string;
+    showArrow?: boolean | VNodeChild;
+    spacing?: number | TooltipSpacing;
+    stopPropagation?: boolean;
+    style?: StyleValue;
+    transformFromCenter?: boolean;
+    trigger?: TooltipTrigger;
+    visible?: boolean;
+    wrapWhenSpecial?: boolean;
+    wrapperClassName?: HTMLAttributes['class'];
+    wrapperId?: string;
+    zIndex?: number;
+}
+export interface TooltipEmits {
+    afterClose: [];
+    clickOutside: [event: MouseEvent];
+    escKeydown: [event: KeyboardEvent];
+    visibleChange: [visible: boolean];
+    'update:visible': [visible: boolean];
+}
+export interface TooltipSlots {
+    default?: () => VNodeChild;
+    content?: (props: {
+        initialFocusRef: TooltipInitialFocusRef;
+    }) => VNodeChild;
+    arrow?: () => VNodeChild;
+}
+export interface TooltipExposed {
+    focusTrigger(): void;
+    getPopupId(): string | undefined;
+    rePosition(): Record<string, unknown>;
+}
+export interface TooltipRuntimeProps extends Omit<TooltipProps, 'class' | 'style'> {
+    arrowBounding: Required<TooltipArrowBounding>;
+    arrowPointAtCenter: boolean;
+    autoAdjustOverflow: boolean;
+    class?: HTMLAttributes['class'];
+    closeOnEsc: boolean;
+    condition: boolean;
+    disableArrowKeyDown: boolean;
+    disableFocusListener: boolean;
+    guardFocus: boolean;
+    keepDOM: boolean;
+    margin: number | TooltipMargin;
+    motion: boolean;
+    mouseEnterDelay: number;
+    mouseLeaveDelay: number;
+    position: TooltipPosition;
+    prefixCls: string;
+    returnFocusOnClose: boolean;
+    role: string;
+    showArrow: boolean | VNodeChild;
+    spacing: number | TooltipSpacing;
+    style?: StyleValue;
+    transformFromCenter: boolean;
+    trigger: TooltipTrigger;
+    wrapWhenSpecial: boolean;
+    zIndex: number;
+}
+export interface TooltipState {
+    containerStyle: Record<string, string | number>;
+    displayNone: boolean;
+    id?: string | undefined;
+    isInsert: boolean;
+    isPositionUpdated: boolean;
+    placement: TooltipPosition;
+    portalEventSet: Record<string, (...args: unknown[]) => void>;
+    transitionState: '' | 'enter' | 'leave';
+    triggerEventSet: Record<string, (...args: unknown[]) => void>;
+    visible: boolean;
+}

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

@@ -0,0 +1,25 @@
+import { ComponentPublicInstance, ComputedRef } from 'vue';
+import { ConfigContextValue } from '../config-provider';
+import { TooltipRuntimeProps, TooltipState } from './types';
+interface TooltipFoundationOptions {
+    config: ComputedRef<ConfigContextValue>;
+    onAfterClose: () => void;
+    onClickOutside: (event: MouseEvent) => void;
+    onEscKeydown: (event: KeyboardEvent) => void;
+    onVisibleChange: (visible: boolean) => void;
+    runtimeProps: ComputedRef<TooltipRuntimeProps>;
+}
+export declare function useTooltipFoundation(options: TooltipFoundationOptions): {
+    animationEnd: (transitionState: "enter" | "leave") => void;
+    animationStart: () => void;
+    focusTrigger: () => void;
+    handleContainerKeydown: (event: KeyboardEvent) => void;
+    hide: () => void;
+    portalTarget: import('vue').ShallowRef<HTMLElement | null, HTMLElement | null>;
+    rePosition: () => Record<string, unknown>;
+    setInitialFocusElement: (element: Element | ComponentPublicInstance | null) => void;
+    setPortalElement: (element: HTMLDivElement | null) => void;
+    setTriggerElement: (element: HTMLElement | null) => void;
+    state: import('vue').ShallowReactive<TooltipState>;
+};
+export {};

package/dist/tooltip-en9bvXRp.js

@@ -0,0 +1,28 @@
+import { t as e } from "./Tooltip-Bq7HZwnS.js";
+//#region src/tooltip/types.ts
+var t = [
+	"top",
+	"topLeft",
+	"topRight",
+	"left",
+	"leftTop",
+	"leftBottom",
+	"right",
+	"rightTop",
+	"rightBottom",
+	"bottom",
+	"bottomLeft",
+	"bottomRight",
+	"leftTopOver",
+	"rightTopOver",
+	"leftBottomOver",
+	"rightBottomOver"
+], n = [
+	"hover",
+	"focus",
+	"click",
+	"custom",
+	"contextMenu"
+], r = e;
+//#endregion
+export { t as n, n as r, r as t };

package/dist/transfer/Transfer.vue.d.ts

@@ -0,0 +1,35 @@
+import { TransferDataItem, TransferDataSource, TransferExposed, TransferPrimitive, TransferProps, TransferSlots } from './types';
+type __VLS_Slots = TransferSlots;
+declare const __VLS_base: import('vue').DefineComponent<TransferProps, TransferExposed, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (input: string) => any;
+    select: (item: TransferDataItem) => any;
+    change: (values: TransferPrimitive[], items: TransferDataItem[]) => any;
+    "update:modelValue": (values: TransferPrimitive[]) => any;
+    "update:value": (values: TransferPrimitive[]) => any;
+    deselect: (item: TransferDataItem) => any;
+}, string, import('vue').PublicProps, Readonly<TransferProps> & Readonly<{
+    onSearch?: (input: string) => any;
+    onSelect?: (item: TransferDataItem) => any;
+    onChange?: (values: TransferPrimitive[], items: TransferDataItem[]) => any;
+    "onUpdate:modelValue"?: (values: TransferPrimitive[]) => any;
+    "onUpdate:value"?: (values: TransferPrimitive[]) => any;
+    onDeselect?: (item: TransferDataItem) => any;
+}>, {
+    disabled: boolean;
+    type: import('./types').TransferType;
+    filter: boolean | ((input: string, item: TransferDataItem) => boolean);
+    defaultValue: TransferPrimitive[];
+    loading: boolean;
+    draggable: boolean;
+    emptyContent: import('./types').TransferEmptyContent;
+    dataSource: TransferDataSource;
+    showPath: 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;
+    };
+};

package/dist/transfer/TransferNodeRenderer.d.ts

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

package/dist/transfer/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+import { TransferProps } from './types';
+export declare const Transfer: DefineComponent<TransferProps>;
+export type { TransferDataItem, TransferDataSource, TransferDragHandleProps, TransferEmits, TransferEmptyContent, TransferExposed, TransferFullPathItem, TransferGroupItem, TransferLocale, TransferPaginationProps, TransferPrimitive, TransferProps, TransferResolvedDataItem, TransferSelectedHeaderProps, TransferSelectedItemProps, TransferSelectedPanelProps, TransferSlots, TransferSourceHeaderProps, TransferSourceItemProps, TransferSourcePanelProps, TransferTreeItem, TransferType, TransferVirtualizeProps, } from './types';
+export default Transfer;

package/dist/transfer/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../transfer-Doq1sI9z.js";
+export { e as Transfer, e as default };

package/dist/transfer/types.d.ts

@@ -0,0 +1,159 @@
+import { CSSProperties, HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { InputProps } from '../input';
+import { TreeProps } from '../tree';
+export type TransferPrimitive = string | number;
+export type TransferType = 'list' | 'groupList' | 'treeList';
+export interface TransferDataItem extends Record<string, unknown> {
+    key: TransferPrimitive;
+    label?: VNodeChild;
+    value?: TransferPrimitive;
+    disabled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    fullPath?: TransferFullPathItem[];
+}
+export type TransferFullPathItem = TransferDataItem;
+export interface TransferGroupItem {
+    title?: string;
+    children?: TransferDataItem[];
+}
+export interface TransferTreeItem extends TransferDataItem {
+    children?: TransferTreeItem[];
+}
+export type TransferDataSource = TransferDataItem[] | TransferGroupItem[] | TransferTreeItem[];
+export interface TransferResolvedDataItem extends TransferDataItem {
+    _parent?: {
+        title?: string;
+    };
+    _optionKey?: TransferPrimitive;
+    path?: TransferFullPathItem[];
+    isLeaf?: boolean;
+}
+export interface TransferEmptyContent {
+    left?: VNodeChild;
+    right?: VNodeChild;
+    search?: VNodeChild;
+}
+export interface TransferVirtualizeProps {
+    height?: number | string;
+    width?: number | string;
+    itemSize: number;
+}
+export interface TransferPaginationProps {
+    currentPage?: number;
+    defaultCurrentPage?: number;
+    pageSize?: number;
+    onPageChange?: (currentPage: number) => void;
+}
+export interface TransferSourceItemProps extends TransferResolvedDataItem {
+    checked: boolean;
+    onChange(): void;
+}
+export interface TransferDragHandleProps extends Record<string, unknown> {
+    draggable: true;
+    role: 'button';
+    'aria-label': 'Drag and sort';
+    onDragstart(event: DragEvent): void;
+    onDragend(): void;
+}
+export interface TransferSelectedItemProps extends TransferResolvedDataItem {
+    onRemove(): void;
+    dragHandleProps?: TransferDragHandleProps;
+    sortableHandle?: (render: () => VNodeChild) => VNodeChild;
+}
+export interface TransferSourceHeaderProps {
+    num: number;
+    showButton: boolean;
+    allChecked: boolean;
+    leafOnlyNum?: number;
+    onAllClick(): void;
+}
+export interface TransferSelectedHeaderProps {
+    num: number;
+    showButton: boolean;
+    onClear(): void;
+}
+export interface TransferSourcePanelProps {
+    value: TransferPrimitive[];
+    loading: boolean;
+    noMatch: boolean;
+    filterData: TransferResolvedDataItem[];
+    sourceData: TransferResolvedDataItem[];
+    propsDataSource: TransferDataSource;
+    allChecked: boolean;
+    showNumber: number;
+    inputValue: string;
+    selectedItems: Map<TransferPrimitive, TransferResolvedDataItem>;
+    onSearch(value: string): void;
+    onAllClick(): void;
+    onSelectOrRemove(item: TransferResolvedDataItem): void;
+    onSelect(value: TransferPrimitive[]): void;
+}
+export interface TransferSelectedPanelProps {
+    length: number;
+    selectedData: TransferResolvedDataItem[];
+    onClear(): void;
+    onRemove(item: TransferResolvedDataItem): void;
+    onSortEnd(props: {
+        oldIndex: number;
+        newIndex: number;
+    }): void;
+}
+export interface TransferLocale {
+    emptyLeft: string;
+    emptySearch: string;
+    emptyRight: string;
+    placeholder: string;
+    clear: string;
+    selectAll: string;
+    clearSelectAll: string;
+    total: string;
+    selected: string;
+}
+export interface TransferProps {
+    className?: HTMLAttributes['class'];
+    style?: StyleValue;
+    disabled?: boolean;
+    dataSource?: TransferDataSource;
+    filter?: boolean | ((input: string, item: TransferDataItem) => boolean);
+    defaultValue?: TransferPrimitive[];
+    value?: TransferPrimitive[] | undefined;
+    modelValue?: TransferPrimitive[] | undefined;
+    inputProps?: InputProps;
+    type?: TransferType;
+    emptyContent?: TransferEmptyContent;
+    draggable?: boolean;
+    treeProps?: Omit<TreeProps, 'value' | 'modelValue'>;
+    showPath?: boolean;
+    loading?: boolean;
+    virtualize?: TransferVirtualizeProps;
+    pagination?: TransferPaginationProps;
+    renderSourceItem?: (item: TransferSourceItemProps) => VNodeChild;
+    renderSelectedItem?: (item: TransferSelectedItemProps) => VNodeChild;
+    renderSourcePanel?: (props: TransferSourcePanelProps) => VNodeChild;
+    renderSelectedPanel?: (props: TransferSelectedPanelProps) => VNodeChild;
+    renderSourceHeader?: (props: TransferSourceHeaderProps) => VNodeChild;
+    renderSelectedHeader?: (props: TransferSelectedHeaderProps) => VNodeChild;
+}
+export interface TransferEmits {
+    change: [values: TransferPrimitive[], items: TransferDataItem[]];
+    select: [item: TransferDataItem];
+    deselect: [item: TransferDataItem];
+    search: [input: string];
+    'update:value': [values: TransferPrimitive[]];
+    'update:modelValue': [values: TransferPrimitive[]];
+}
+export interface TransferSlots {
+    sourceItem?: (props: TransferSourceItemProps) => VNodeChild;
+    selectedItem?: (props: TransferSelectedItemProps) => VNodeChild;
+    sourcePanel?: (props: TransferSourcePanelProps) => VNodeChild;
+    selectedPanel?: (props: TransferSelectedPanelProps) => VNodeChild;
+    sourceHeader?: (props: TransferSourceHeaderProps) => VNodeChild;
+    selectedHeader?: (props: TransferSelectedHeaderProps) => VNodeChild;
+    emptyLeft?: () => VNodeChild;
+    emptyRight?: () => VNodeChild;
+    emptySearch?: () => VNodeChild;
+}
+export interface TransferExposed {
+    search(value: string): void;
+}