lew-ui 2.7.20 → 2.7.22

package/dist/components/general/avatar/src/LewAvatar.vue.d.ts

@@ -0,0 +1,111 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    shape: {
+        type: PropType<import('../../../..').LewAvatarShape>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    src: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    alt: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    status: {
+        type: PropType<import('../../../..').LewAvatarStatus>;
+        typeValues: string[];
+        validator: (value: any) => boolean;
+    };
+    objectFit: {
+        type: PropType<import('../../../..').LewImageObjectFit>;
+        typeValues: import('../../../..').LewImageObjectFit[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    objectPosition: {
+        type: PropType<import('../../../..').LewImageObjectPosition>;
+        typeValues: import('../../../..').LewImageObjectPosition[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    statusPlacement: {
+        type: PropType<import('../../../..').LewAvatarPlacement>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: () => void;
+    load: () => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    shape: {
+        type: PropType<import('../../../..').LewAvatarShape>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    src: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    alt: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    status: {
+        type: PropType<import('../../../..').LewAvatarStatus>;
+        typeValues: string[];
+        validator: (value: any) => boolean;
+    };
+    objectFit: {
+        type: PropType<import('../../../..').LewImageObjectFit>;
+        typeValues: import('../../../..').LewImageObjectFit[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    objectPosition: {
+        type: PropType<import('../../../..').LewImageObjectPosition>;
+        typeValues: import('../../../..').LewImageObjectPosition[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    statusPlacement: {
+        type: PropType<import('../../../..').LewAvatarPlacement>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+}>> & Readonly<{
+    onError?: (() => any) | undefined;
+    onLoad?: (() => any) | undefined;
+}>, {
+    loading: boolean;
+    size: string;
+    objectFit: import('../../../..').LewImageObjectFit;
+    objectPosition: import('../../../..').LewImageObjectPosition;
+    shape: import('../../../..').LewAvatarShape;
+    statusPlacement: import('../../../..').LewAvatarPlacement;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/components/general/avatar/src/emits.d.ts

@@ -0,0 +1,4 @@
+export declare const avatarEmits: {
+    readonly load: () => void;
+    readonly error: () => void;
+};

package/dist/components/general/avatar/src/props.d.ts

@@ -0,0 +1,52 @@
+import { LewAvatarPlacement, LewAvatarShape, LewAvatarStatus, LewImageObjectFit, LewImageObjectPosition } from '../../../..';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export declare const avatarProps: {
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    shape: {
+        type: PropType<LewAvatarShape>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    src: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    alt: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    status: {
+        type: PropType<LewAvatarStatus>;
+        typeValues: string[];
+        validator: (value: any) => boolean;
+    };
+    objectFit: {
+        type: PropType<LewImageObjectFit>;
+        typeValues: LewImageObjectFit[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    objectPosition: {
+        type: PropType<LewImageObjectPosition>;
+        typeValues: LewImageObjectPosition[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    statusPlacement: {
+        type: PropType<LewAvatarPlacement>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+};
+export type LewAvatarProps = ExtractPublicPropTypes<typeof avatarProps>;

package/dist/components/general/badge/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LewBadge } from './src/LewBadge.vue';
+export * from './src/props';

package/dist/components/general/badge/src/LewBadge.vue.d.ts

@@ -0,0 +1,85 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    offset: {
+        type: PropType<import('../../../..').LewOffset>;
+        default: () => import('../../../..').LewOffset;
+        validator: (value: any[] | undefined) => boolean;
+    };
+    processing: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: any) => boolean;
+    };
+    color: {
+        type: PropType<import('../../../..').LewColor>;
+        typeValues: import('../../../..').LewColor[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    value: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    offset: {
+        type: PropType<import('../../../..').LewOffset>;
+        default: () => import('../../../..').LewOffset;
+        validator: (value: any[] | undefined) => boolean;
+    };
+    processing: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: any) => boolean;
+    };
+    color: {
+        type: PropType<import('../../../..').LewColor>;
+        typeValues: import('../../../..').LewColor[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    value: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+}>> & Readonly<{}>, {
+    text: string;
+    processing: boolean;
+    max: number;
+    color: import('../../../..').LewColor;
+    offset: import('../../../..').LewOffset;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/general/badge/src/props.d.ts

@@ -0,0 +1,35 @@
+import { LewColor, LewOffset } from '../../../..';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export declare const badgeProps: {
+    text: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    offset: {
+        type: PropType<LewOffset>;
+        default: () => LewOffset;
+        validator: (value: any[] | undefined) => boolean;
+    };
+    processing: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: any) => boolean;
+    };
+    color: {
+        type: PropType<LewColor>;
+        typeValues: LewColor[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    value: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+};
+export type LewBadgeProps = ExtractPublicPropTypes<typeof badgeProps>;

package/dist/components/general/button/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LewButton } from './src/LewButton.vue';
+export * from './src/props';

package/dist/components/general/button/src/LewButton.vue.d.ts

@@ -0,0 +1,147 @@
+declare function focus(): void;
+declare function blur(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        buttonRef: HTMLButtonElement;
+    };
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    type: {
+        type: PropType<import('../../../..').LewButtonType>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    size: {
+        type: PropType<import('../../../..').LewButtonSize>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    singleIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    color: {
+        type: PropType<import('../../../..').LewColor>;
+        default: string;
+        typeValues: import('../../../..').LewColor[];
+        validator: (value: any) => boolean;
+    };
+    round: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    dashed: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    request: {
+        type: PropType<() => Promise<void>>;
+        validator: (value: any) => boolean;
+    };
+}>, {
+    focus: typeof focus;
+    blur: typeof blur;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    type: {
+        type: PropType<import('../../../..').LewButtonType>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    size: {
+        type: PropType<import('../../../..').LewButtonSize>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    singleIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    color: {
+        type: PropType<import('../../../..').LewColor>;
+        default: string;
+        typeValues: import('../../../..').LewColor[];
+        validator: (value: any) => boolean;
+    };
+    round: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    dashed: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    request: {
+        type: PropType<() => Promise<void>>;
+        validator: (value: any) => boolean;
+    };
+}>> & Readonly<{}>, {
+    loading: boolean;
+    type: import('../../../..').LewButtonType;
+    color: import('../../../..').LewColor;
+    size: import('../../../..').LewButtonSize;
+    round: boolean;
+    disabled: boolean;
+    singleIcon: boolean;
+    dashed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    buttonRef: HTMLButtonElement;
+}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/general/button/src/props.d.ts

@@ -0,0 +1,61 @@
+import { Property } from 'csstype';
+import { LewButtonSize, LewButtonType, LewColor } from '../../../..';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export declare const buttonProps: {
+    text: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    width: {
+        type: PropType<Property.Width>;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    type: {
+        type: PropType<LewButtonType>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    size: {
+        type: PropType<LewButtonSize>;
+        typeValues: string[];
+        default: string;
+        validator: (value: any) => boolean;
+    };
+    singleIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    color: {
+        type: PropType<LewColor>;
+        default: string;
+        typeValues: LewColor[];
+        validator: (value: any) => boolean;
+    };
+    round: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    dashed: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    request: {
+        type: PropType<() => Promise<void>>;
+        validator: (value: any) => boolean;
+    };
+};
+export type LewButtonProps = ExtractPublicPropTypes<typeof buttonProps>;

package/dist/components/general/flex/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LewFlex } from './src/LewFlex.vue';
+export * from './src/props';

package/dist/components/general/flex/src/LewFlex.vue.d.ts

@@ -0,0 +1,99 @@
+import { LewXAlignment, LewYAlignment } from '../../../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    direction: {
+        type: PropType<import('../../../../types').LewDirection>;
+        default: string;
+        typeValues: import('../../../../types').LewDirection[];
+        validator: (value: any) => boolean;
+    };
+    x: {
+        type: PropType<LewXAlignment>;
+        default: string;
+        typeValues: LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    y: {
+        type: PropType<LewYAlignment>;
+        default: string;
+        typeValues: LewYAlignment[];
+        validator: (value: any) => boolean;
+    };
+    mode: {
+        type: PropType<import('./props').FlexMode>;
+        validator: (value: any) => boolean;
+    };
+    wrap: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+    gap: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    direction: {
+        type: PropType<import('../../../../types').LewDirection>;
+        default: string;
+        typeValues: import('../../../../types').LewDirection[];
+        validator: (value: any) => boolean;
+    };
+    x: {
+        type: PropType<LewXAlignment>;
+        default: string;
+        typeValues: LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    y: {
+        type: PropType<LewYAlignment>;
+        default: string;
+        typeValues: LewYAlignment[];
+        validator: (value: any) => boolean;
+    };
+    mode: {
+        type: PropType<import('./props').FlexMode>;
+        validator: (value: any) => boolean;
+    };
+    wrap: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+    gap: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+}>> & Readonly<{}>, {
+    x: LewXAlignment;
+    y: LewYAlignment;
+    direction: import('../../../../types').LewDirection;
+    width: string;
+    gap: string;
+    wrap: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/general/flex/src/props.d.ts

@@ -0,0 +1,42 @@
+import { LewDirection, LewXAlignment, LewYAlignment } from '../../../../types';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export type FlexMode = 'around' | 'between';
+export declare const flexProps: {
+    direction: {
+        type: PropType<LewDirection>;
+        default: string;
+        typeValues: LewDirection[];
+        validator: (value: any) => boolean;
+    };
+    x: {
+        type: PropType<LewXAlignment>;
+        default: string;
+        typeValues: LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    y: {
+        type: PropType<LewYAlignment>;
+        default: string;
+        typeValues: LewYAlignment[];
+        validator: (value: any) => boolean;
+    };
+    mode: {
+        type: PropType<FlexMode>;
+        validator: (value: any) => boolean;
+    };
+    wrap: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+    gap: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+};
+export type LewFlexProps = ExtractPublicPropTypes<typeof flexProps>;

package/dist/components/general/image/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/emits';
+export { default as LewImage } from './src/LewImage.vue';
+export * from './src/props';