lew-ui 2.7.20 → 2.7.22

package/dist/methods/dialog/src/props.d.ts

@@ -0,0 +1,64 @@
+import { LewDialogType } from '../../..';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export declare const dialogProps: {
+    icon: {
+        type: null;
+        typePopKeys: string[];
+    };
+    title: {
+        type: null;
+        typePopKeys: string[];
+    };
+    content: {
+        type: null;
+        typePopKeys: string[];
+    };
+    type: {
+        type: PropType<LewDialogType>;
+        default: string;
+        typeValues: LewDialogType[];
+        validator: (value: any) => boolean;
+    };
+    hideIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    okText: {
+        type: StringConstructor;
+        defaultLocale: boolean;
+        validator: (value: any) => boolean;
+    };
+    cancelText: {
+        type: StringConstructor;
+        defaultLocale: boolean;
+        validator: (value: any) => boolean;
+    };
+    ok: {
+        type: PropType<() => Promise<boolean>>;
+        default: () => Promise<boolean>;
+        validator: (value: any) => boolean;
+    };
+    cancel: {
+        type: PropType<() => Promise<boolean>>;
+        default: () => Promise<boolean>;
+        validator: (value: any) => boolean;
+    };
+    closeOnClickOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    closeByEsc: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    transformOrigin: {
+        type: StringConstructor;
+        default: string;
+        hidden: boolean;
+        validator: (value: any) => boolean;
+    };
+};
+export type LewDialogProps = ExtractPublicPropTypes<typeof dialogProps>;

package/dist/methods/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dialog';
+export * from './message';
+export * from './notification';

package/dist/methods/message/index.d.ts

@@ -0,0 +1 @@
+export { default as LewMessage } from './src';

package/dist/methods/message/src/index.d.ts

@@ -0,0 +1,3 @@
+import { LewMessageInstance } from '../../../types';
+declare const LewMessage: LewMessageInstance;
+export default LewMessage;

package/dist/methods/notification/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/dist/methods/notification/src/NotificationContainer.vue.d.ts

@@ -0,0 +1,7 @@
+declare function add(type: string, title: string, content: string, duration: number, showProgress: boolean, width: number | string): string;
+declare function handleClose(id: string): void;
+declare const _default: import('vue').DefineComponent<{}, {
+    add: typeof add;
+    handleClose: typeof handleClose;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/methods/notification/src/NotificationItem.vue.d.ts

@@ -0,0 +1,14 @@
+type __VLS_Props = {
+    type: string;
+    title: string;
+    content: string;
+    duration: number;
+    showProgress: boolean;
+    width: number | string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/methods/notification/src/emits.d.ts

@@ -0,0 +1,3 @@
+export declare const notificationEmits: {
+    readonly close: () => boolean;
+};

package/dist/methods/notification/src/index.d.ts

@@ -0,0 +1,2 @@
+import { LewNotificationInstance } from '../../../types';
+export declare const LewNotification: LewNotificationInstance;

package/dist/render/components/CommonIcon.vue.d.ts

@@ -0,0 +1,77 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    dark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    speed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    dark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    speed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    loading: boolean;
+    fill: string;
+    type: string;
+    color: string;
+    size: number;
+    dark: boolean;
+    strokeWidth: number;
+    speed: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/render/components/RenderComponent.vue.d.ts

@@ -0,0 +1,31 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    renderFn: {
+        type: null;
+        required: true;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    componentProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    renderFn: {
+        type: null;
+        required: true;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    componentProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    type: string;
+    componentProps: Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/render/components/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CommonIcon } from './CommonIcon.vue';
+export { default as RenderComponent } from './RenderComponent.vue';

package/dist/render/index.d.ts

@@ -0,0 +1,15 @@
+import { Component } from 'vue';
+import { LewComponentSource } from '../types';
+/**
+ * 检查组件是否有效（可以被渲染）
+ * @param componentSource 组件源
+ * @returns 是否有效
+ */
+export declare function isValidComponent(componentSource: LewComponentSource): boolean;
+/**
+ * 格式化输入为有效的 Vue 组件
+ * @param componentSource 可能是组件、组件名称、配置对象等
+ * @returns 有效的 Vue 组件
+ */
+export declare function formatComponent(componentSource: LewComponentSource): Component | undefined;
+export * from './components';

package/dist/types/base.d.ts

@@ -0,0 +1,13 @@
+import { Component, VNode } from 'vue';
+export type LewThemeColor = 'black' | 'blue' | 'brown' | 'cyan' | 'gray' | 'green' | 'indigo' | 'mint' | 'orange' | 'pink' | 'purple' | 'red' | 'teal' | 'yellow';
+export type LewStatusColor = 'error' | 'success' | 'warning' | 'info' | 'normal' | 'primary' | 'danger';
+export type LewColor = LewThemeColor | LewStatusColor;
+export type LewSize = 'small' | 'medium' | 'large';
+export type LewDirection = 'x' | 'y';
+export type LewComponentSource = string | number | boolean | VNode | Component | ((...args: any[]) => any) | Promise<Component> | Record<string, any> | null | undefined;
+export type LewXAlignment = 'start' | 'center' | 'end' | 'left' | 'right';
+export type LewYAlignment = 'start' | 'center' | 'end' | 'top' | 'bottom';
+export type LewStatus = 'pending' | 'loading' | 'done' | 'error' | 'warning';
+export type LewTrigger = 'hover' | 'click' | 'mouseenter' | 'manual';
+export type LewPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export type LewOffset = [number, number];

package/dist/types/components.d.ts

@@ -0,0 +1,250 @@
+import { Property } from 'csstype';
+import { LewTagProps } from '..';
+import { LewComponentSource, LewDirection, LewSize } from './base';
+export type LewButtonType = 'fill' | 'light' | 'ghost' | 'text';
+export type LewButtonSize = 'mini' | 'small' | 'medium' | 'large';
+export type LewTagType = 'fill' | 'light' | 'ghost';
+export type LewAvatarPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type LewAvatarStatus = 'online' | 'processing' | 'away' | 'offline' | 'busy';
+export type LewAvatarShape = 'circle' | 'square' | 'sharp';
+export type LewImageObjectFit = 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+export type LewImageObjectPosition = 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top left' | 'top right' | 'bottom left' | 'bottom right';
+export type LewInputType = 'text' | 'password';
+export type LewInputPrefixesType = 'icon' | 'select' | 'text';
+export type LewInputSuffixType = 'icon' | 'select' | 'text';
+export type LewTextareaResize = 'none' | 'both' | 'horizontal' | 'vertical';
+export type LewTabsType = 'block' | 'line';
+export type LewBreadcrumbSeparator = 'shoulder' | 'sprit';
+export type LewUploadStatus = 'success' | 'fail' | 'uploading' | 'complete' | 'wrong_type' | 'wrong_size' | 'pending';
+export type LewFormItemAs = 'input' | 'textarea' | 'input-tag' | 'checkbox-group' | 'radio-group' | 'checkbox' | 'select' | 'select-multiple' | 'date-picker' | 'date-range-picker' | 'tabs' | 'cascader' | 'switch' | 'button' | 'upload' | 'input-number' | 'slider' | 'slider-range' | 'color-picker' | 'rate' | 'tree-select';
+export type LewSelectMultipleValueLayout = 'tag' | 'text';
+export type LewStepsStatus = 'pending' | 'loading' | 'done' | 'error' | 'warning';
+export type LewTagClose = () => Promise<boolean>;
+export type LewEmptyType = '404' | 'address' | 'article' | 'goods' | 'likes' | 'car' | 'comment' | 'network' | 'order' | 'search';
+export type LewPopokType = 'error' | 'warning' | 'success' | 'info' | 'normal';
+export type LewDrawerPosition = 'left' | 'right' | 'top' | 'bottom';
+export interface LewActionBoxOption {
+    label: LewComponentSource;
+    icon?: LewComponentSource;
+    customRender?: LewComponentSource;
+    onClick?: (event?: MouseEvent) => void;
+}
+export interface LewBreadcrumbOption {
+    label: string;
+    value?: string;
+    active?: boolean;
+}
+export interface LewStepsOption {
+    title: LewComponentSource;
+    description?: LewComponentSource;
+}
+export interface LewTabsOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+export interface LewMenuOption {
+    label: string;
+    value?: string;
+    icon?: LewComponentSource;
+    disabled?: boolean;
+    children?: LewMenuOption[];
+    tagProps?: LewTagProps;
+}
+export interface LewMenuTreeOption {
+    label: LewComponentSource;
+    value: string;
+    icon?: LewComponentSource;
+    active?: boolean;
+    disabled?: boolean;
+    children?: LewMenuTreeOption[];
+    tagProps?: LewTagProps;
+}
+export interface LewContextMenusOption {
+    label?: LewComponentSource;
+    value?: string;
+    icon?: LewComponentSource;
+    disabled?: boolean;
+    checkable?: boolean;
+    checked?: boolean;
+    isDividerLine?: boolean;
+    level?: number;
+    children?: LewContextMenusOption[];
+    onClick?: (item: LewContextMenusOption, options: LewContextMenusOption[], instance: any) => void;
+    [key: string]: any;
+}
+export interface LewHoverMenusOption {
+    label?: LewComponentSource;
+    value?: string;
+    type?: string;
+    icon?: LewComponentSource;
+    disabled?: boolean;
+    isDividerLine?: boolean;
+    level?: number;
+    children?: LewHoverMenusOption[];
+    onClick?: (item: LewHoverMenusOption) => void;
+    [key: string]: any;
+}
+export interface LewInputTableColumn {
+    title: string;
+    width?: number;
+    field: string;
+    as: string;
+}
+export interface LewTableColumn {
+    title: string;
+    field: string;
+    fixed?: 'left' | 'right';
+    width?: number;
+    x?: string;
+    y?: string;
+    columnStyle?: string;
+    sortable?: boolean;
+}
+export interface LewDescOption {
+    label: string;
+    field: string;
+    direction?: LewDirection;
+    size?: LewSize;
+    width?: string;
+    labelWidth?: string;
+    tips?: string;
+    type?: 'text-trim';
+    gridArea?: string;
+    labelX?: Property.TextAlign;
+    valueX?: Property.TextAlign;
+    customRender?: LewComponentSource;
+}
+export interface LewFormOption {
+    label?: string;
+    field: string;
+    required?: boolean;
+    as?: LewFormItemAs | '';
+    size?: LewSize;
+    width?: Property.Width;
+    labelWidth?: Property.Width;
+    direction?: LewDirection;
+    disabled?: boolean;
+    readonly?: boolean;
+    tips?: string;
+    errMessage?: string;
+    rule?: any | string;
+    props?: Record<string, any>;
+    between?: boolean;
+    gridArea?: string;
+    id?: string;
+    outputFormat?: (params: {
+        value: unknown;
+        item?: LewFormOption;
+    }) => unknown;
+    inputFormat?: (params: {
+        value: unknown;
+        item?: LewFormOption;
+    }) => unknown;
+}
+export interface LewSelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    isGroup?: boolean;
+    groupValue?: string;
+    groupLabel?: string;
+}
+export interface LewTreeSelectOption {
+    label: string;
+    value: string;
+    level: number;
+    labelPaths?: string[];
+    keysPaths?: string[];
+    isLeaf?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    parentLabelPaths?: string[];
+    parentKeysPaths?: string[];
+    parentChildren?: LewTreeSelectOption[];
+    children?: LewTreeSelectOption[];
+}
+export interface LewSelectMultipleOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    isGroup?: boolean;
+    groupValue?: string;
+    groupLabel?: string;
+}
+export interface LewCheckboxOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+export interface LewRadioOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+export interface LewSliderOption {
+    label: string;
+    value: number;
+}
+export interface LewSliderRangeOption {
+    label: string;
+    value: number;
+}
+export interface LewDatePickerPresetsOption {
+    label: string;
+    value: string;
+}
+export interface LewCascaderOption {
+    label: string;
+    value: string;
+    level?: number;
+    labelPaths?: string[];
+    valuePaths?: string[];
+    isLeaf?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    parentLabelPaths?: string[];
+    parentValuePaths?: string[];
+    children?: LewCascaderOption[];
+}
+export interface LewTreeDataSource {
+    label: string;
+    key: string;
+    level: number;
+    isLeaf?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    parentKey?: string;
+    treeIndex?: number;
+    labelPaths?: string[];
+    valueKeys?: string[];
+    parentKeyPaths?: string[];
+    parentLabelPaths?: string[];
+    allNodeValues: string[];
+    leafNodeValues: string[];
+    children?: LewTreeDataSource[];
+}
+export interface LewUploadFileItem {
+    key: string;
+    name?: string;
+    url?: string;
+    status?: LewUploadStatus;
+    percent?: number;
+    file?: File;
+    size?: number;
+    type?: string;
+    lastModifiedDate?: string;
+    lastModified?: number;
+}
+export interface LewSelectSearchMethodParams {
+    options?: LewSelectOption[];
+    keyword?: string;
+}
+export interface LewTreeSelectSearchMethodParams {
+    item?: LewTreeDataSource;
+    keyword?: string;
+}
+export interface LewSelectSearchMultipleMethodParams {
+    options?: LewSelectMultipleOption[];
+    keyword?: string;
+}

package/dist/types/directives.d.ts

@@ -0,0 +1,32 @@
+import { LewPlacement, LewTrigger } from './base';
+import { LewContextMenusOption, LewHoverMenusOption } from './components';
+export interface LewTooltipDirectiveBinding {
+    trigger?: LewTrigger;
+    content?: any;
+    placement?: LewPlacement;
+    delay?: number | [number, number];
+    triggerFrom?: string;
+}
+export interface LewLoadingDirectiveBinding {
+    tip?: string;
+    iconSize?: number;
+    visible?: boolean;
+}
+export interface LewBackTopDirectiveBinding {
+    target?: string;
+}
+export interface LewContextMenuDirectiveBinding {
+    options?: LewContextMenusOption[];
+    disabled?: boolean;
+}
+export interface LewHoverMenuDirectiveBinding {
+    options?: LewHoverMenusOption[];
+    disabled?: boolean;
+}
+export interface LewDirectiveBindings {
+    'tooltip': LewTooltipDirectiveBinding;
+    'loading': LewLoadingDirectiveBinding;
+    'backtop': LewBackTopDirectiveBinding;
+    'context-menu': LewContextMenuDirectiveBinding;
+    'hover-menu': LewHoverMenuDirectiveBinding;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './components';
+export * from './directives';
+export * from './methods';
+export * from './model';

package/dist/types/methods.d.ts

@@ -0,0 +1,95 @@
+import { LewComponentSource } from '..';
+export interface LewDialogOptions {
+    type?: LewDialogType;
+    icon?: LewComponentSource;
+    title?: LewComponentSource;
+    content?: LewComponentSource;
+    hideIcon?: boolean;
+    ok?: () => Promise<boolean>;
+    cancel?: () => Promise<boolean>;
+    okText?: string;
+    cancelText?: string;
+    closeOnClickOverlay?: boolean;
+    closeByEsc?: boolean;
+}
+export type LewDialogType = 'warning' | 'error' | 'info' | 'normal' | 'success';
+export interface LewDialogMethod {
+    (options: LewDialogOptions): void;
+}
+export interface LewDialogInstance {
+    name: string;
+    warning: LewDialogMethod;
+    error: LewDialogMethod;
+    info: LewDialogMethod;
+    normal: LewDialogMethod;
+    success: LewDialogMethod;
+}
+export interface LewMessageOptions {
+    id?: string;
+    content: string;
+    duration?: number;
+    onClose?: () => void;
+}
+export interface LewMessageRequestOptions {
+    loadingMessage: string;
+}
+export interface LewMessageRequestResult {
+    content?: string;
+    duration?: number;
+    type?: string;
+}
+export interface LewMessageRequestErrorResult {
+    content?: string;
+    duration?: number;
+}
+export type LewMessageType = 'warning' | 'error' | 'info' | 'normal' | 'success' | 'loading';
+export interface LewMessageMethod {
+    (content: string | LewMessageOptions): void;
+}
+export interface LewMessageCloseMethod {
+    (options: {
+        id: string;
+    }): void;
+}
+export interface LewMessageRequestMethod {
+    (options: LewMessageRequestOptions, asyncFn: () => Promise<LewMessageRequestResult>): Promise<void>;
+}
+export interface LewMessageInstance {
+    name: string;
+    timer: Record<string, NodeJS.Timeout>;
+    warning: LewMessageMethod;
+    error: LewMessageMethod;
+    info: LewMessageMethod;
+    normal: LewMessageMethod;
+    success: LewMessageMethod;
+    loading: LewMessageMethod;
+    close: LewMessageCloseMethod;
+    request: LewMessageRequestMethod;
+    message: (options: {
+        type: string;
+        e: LewMessageOptions;
+    }) => void;
+    [key: string]: any;
+}
+export interface LewNotificationOptions {
+    title: string;
+    content: string;
+    duration?: number;
+    showProgress?: boolean;
+    width?: number | string;
+}
+export interface LewNotificationResult {
+    close: () => void;
+}
+export interface LewNotificationMethod {
+    (options: LewNotificationOptions): LewNotificationResult;
+}
+export type LewNotificationType = 'warning' | 'info' | 'normal' | 'success' | 'error';
+export interface LewNotificationInstance {
+    name: string;
+    warning: LewNotificationMethod;
+    info: LewNotificationMethod;
+    normal: LewNotificationMethod;
+    success: LewNotificationMethod;
+    error: LewNotificationMethod;
+}

package/dist/types/model.d.ts

@@ -0,0 +1 @@
+export type LewCollapseModelValue = (string | number)[] | string | number | null;

package/dist/utils/dragmove.d.ts

@@ -0,0 +1,16 @@
+export declare function dragmove({ el, parentEl, direction, callback, max, min, step, trackMax, trackMin, }: {
+    el: HTMLElement;
+    parentEl: HTMLElement;
+    direction?: 'horizontal' | 'vertical' | 'both';
+    callback?: (position: {
+        x: number;
+        y: number;
+        percentX: number;
+        percentY: number;
+    }) => void;
+    max: () => number;
+    min: () => number;
+    step?: () => number;
+    trackMax: () => number;
+    trackMin: () => number;
+}): () => void;