@antsoo-lib/components 0.0.1

package/dist/src/segmented/src/segmented.d.ts

@@ -0,0 +1,127 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { CustomSlotsType, VueNode } from '../../_util/type';
+export type SegmentedValue = string | number;
+export type segmentedSize = 'large' | 'small';
+export interface SegmentedBaseOption {
+    value: string | number;
+    disabled?: boolean;
+    payload?: any;
+    /**
+     * html `title` property for label
+     */
+    title?: string;
+    className?: string;
+}
+export interface SegmentedOption extends SegmentedBaseOption {
+    label?: VueNode | ((option: SegmentedBaseOption) => VueNode);
+}
+export declare const segmentedProps: () => {
+    prefixCls: StringConstructor;
+    options: {
+        type: PropType<(string | number | SegmentedOption)[]>;
+        default: (string | number | SegmentedOption)[];
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<segmentedSize>;
+        default: segmentedSize;
+    };
+    value: {
+        required: boolean;
+        type: PropType<SegmentedValue>;
+        default: SegmentedValue;
+    };
+    motionName: StringConstructor;
+    onChange: {
+        type: PropType<(val: SegmentedValue) => void>;
+        default: (val: SegmentedValue) => void;
+    };
+    'onUpdate:value': {
+        type: PropType<(val: SegmentedValue) => void>;
+        default: (val: SegmentedValue) => void;
+    };
+};
+export type SegmentedProps = Partial<ExtractPropTypes<ReturnType<typeof segmentedProps>>>;
+declare const _default: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    options: {
+        type: PropType<(string | number | SegmentedOption)[]>;
+        default: (string | number | SegmentedOption)[];
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<segmentedSize>;
+        default: segmentedSize;
+    };
+    value: {
+        required: boolean;
+        type: PropType<SegmentedValue>;
+        default: SegmentedValue;
+    };
+    motionName: StringConstructor;
+    onChange: {
+        type: PropType<(val: SegmentedValue) => void>;
+        default: (val: SegmentedValue) => void;
+    };
+    'onUpdate:value': {
+        type: PropType<(val: SegmentedValue) => void>;
+        default: (val: SegmentedValue) => void;
+    };
+}>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    options: {
+        type: PropType<(string | number | SegmentedOption)[]>;
+        default: (string | number | SegmentedOption)[];
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<segmentedSize>;
+        default: segmentedSize;
+    };
+    value: {
+        required: boolean;
+        type: PropType<SegmentedValue>;
+        default: SegmentedValue;
+    };
+    motionName: StringConstructor;
+    onChange: {
+        type: PropType<(val: SegmentedValue) => void>;
+        default: (val: SegmentedValue) => void;
+    };
+    'onUpdate:value': {
+        type: PropType<(val: SegmentedValue) => void>;
+        default: (val: SegmentedValue) => void;
+    };
+}>> & Readonly<{}>, {
+    size: segmentedSize;
+    value: SegmentedValue;
+    block: boolean;
+    disabled: boolean;
+    onChange: (val: SegmentedValue) => void;
+    'onUpdate:value': (val: SegmentedValue) => void;
+    options: (string | number | SegmentedOption)[];
+}, CustomSlotsType<{
+    label: SegmentedBaseOption;
+}>, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/segmented/style/index.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { UseComponentStyleResult } from '../../theme/internal';
+export interface ComponentToken {
+}
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/select/style/dropdown.d.ts

@@ -0,0 +1,4 @@
+import { SelectToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const genSingleStyle: GenerateStyle<SelectToken>;
+export default genSingleStyle;

package/dist/src/select/style/index.d.ts

@@ -0,0 +1,11 @@
+import { FullToken, UseComponentStyleResult } from '../../theme/internal';
+import { Ref } from 'vue';
+export interface ComponentToken {
+    zIndexPopup: number;
+}
+export interface SelectToken extends FullToken<'Select'> {
+    rootPrefixCls: string;
+    inputPaddingHorizontalBase: number;
+}
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/select/style/multiple.d.ts

@@ -0,0 +1,3 @@
+import { SelectToken } from '.';
+import { CSSInterpolation } from '../../_util/cssinjs';
+export default function genMultipleStyle(token: SelectToken): CSSInterpolation;

package/dist/src/select/style/single.d.ts

@@ -0,0 +1,3 @@
+import { SelectToken } from '.';
+import { CSSInterpolation } from '../../_util/cssinjs';
+export default function genSingleStyle(token: SelectToken): CSSInterpolation;

package/dist/src/select/utils/iconUtil.d.ts

@@ -0,0 +1,9 @@
+export default function getIcons(props: any, slots?: any): {
+    clearIcon: any;
+    suffixIcon: import("vue/jsx-runtime").JSX.Element | (({ open, showSearch }: {
+        open: boolean;
+        showSearch: boolean;
+    }) => import("vue/jsx-runtime").JSX.Element);
+    itemIcon: any;
+    removeIcon: any;
+};

package/dist/src/skeleton/Avatar.d.ts

@@ -0,0 +1,32 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueNode } from '../_util/type';
+export declare const avatarProps: () => {
+    shape: PropType<"circle" | "square">;
+    prefixCls: StringConstructor;
+    size: PropType<"large" | "small" | "default" | number>;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export type SkeletonAvatarProps = Partial<ExtractPropTypes<ReturnType<typeof avatarProps>>>;
+declare const SkeletonAvatar: DefineComponent<ExtractPropTypes<{
+    shape: PropType<"circle" | "square">;
+    prefixCls: StringConstructor;
+    size: PropType<"large" | "small" | "default" | number>;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    shape: PropType<"circle" | "square">;
+    prefixCls: StringConstructor;
+    size: PropType<"large" | "small" | "default" | number>;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    active: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default SkeletonAvatar;

package/dist/src/skeleton/Button.d.ts

@@ -0,0 +1,36 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueNode } from '../_util/type';
+export declare const skeletonButtonProps: () => {
+    size: PropType<"large" | "small" | "default">;
+    block: BooleanConstructor;
+    prefixCls: StringConstructor;
+    shape: PropType<"circle" | "square" | "round" | "default">;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export type SkeletonButtonProps = Partial<ExtractPropTypes<ReturnType<typeof skeletonButtonProps>>>;
+declare const SkeletonButton: DefineComponent<ExtractPropTypes<{
+    size: PropType<"large" | "small" | "default">;
+    block: BooleanConstructor;
+    prefixCls: StringConstructor;
+    shape: PropType<"circle" | "square" | "round" | "default">;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    size: PropType<"large" | "small" | "default">;
+    block: BooleanConstructor;
+    prefixCls: StringConstructor;
+    shape: PropType<"circle" | "square" | "round" | "default">;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    block: boolean;
+    active: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default SkeletonButton;

package/dist/src/skeleton/Element.d.ts

@@ -0,0 +1,13 @@
+import { ExtractPropTypes, FunctionalComponent, PropType } from 'vue';
+export declare const skeletonElementProps: () => {
+    prefixCls: StringConstructor;
+    size: PropType<"large" | "small" | "default" | number>;
+    shape: PropType<"circle" | "square" | "round" | "default">;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export type SkeletonElementProps = Partial<ExtractPropTypes<ReturnType<typeof skeletonElementProps>>>;
+declare const Element: FunctionalComponent<SkeletonElementProps>;
+export default Element;

package/dist/src/skeleton/Image.d.ts

@@ -0,0 +1,22 @@
+import { SkeletonElementProps } from './Element';
+import { DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueNode } from '../_util/type';
+export type SkeletonImageProps = Omit<SkeletonElementProps, 'size' | 'shape' | 'active'>;
+declare const SkeletonImage: DefineComponent<ExtractPropTypes<Omit<{
+    prefixCls: StringConstructor;
+    size: PropType<"large" | "small" | "default" | number>;
+    shape: PropType<"circle" | "square" | "round" | "default">;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}, "size" | "active" | "shape">>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<Omit<{
+    prefixCls: StringConstructor;
+    size: PropType<"large" | "small" | "default" | number>;
+    shape: PropType<"circle" | "square" | "round" | "default">;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}, "size" | "active" | "shape">>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default SkeletonImage;

package/dist/src/skeleton/Input.d.ts

@@ -0,0 +1,28 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { SkeletonElementProps } from './Element';
+import { VueNode } from '../_util/type';
+export interface SkeletonInputProps extends Omit<SkeletonElementProps, 'size' | 'shape'> {
+    size?: 'large' | 'small' | 'default';
+    block?: boolean;
+}
+declare const SkeletonInput: DefineComponent<ExtractPropTypes<{
+    size: PropType<"large" | "small" | "default">;
+    block: BooleanConstructor;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+}>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    size: PropType<"large" | "small" | "default">;
+    block: BooleanConstructor;
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+}>> & Readonly<{}>, {
+    block: boolean;
+    active: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default SkeletonInput;

package/dist/src/skeleton/Paragraph.d.ts

@@ -0,0 +1,24 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type widthUnit = number | string;
+export declare const skeletonParagraphProps: () => {
+    prefixCls: StringConstructor;
+    width: {
+        type: PropType<widthUnit[] | widthUnit>;
+    };
+    rows: NumberConstructor;
+};
+export type SkeletonParagraphProps = Partial<ExtractPropTypes<ReturnType<typeof skeletonParagraphProps>>>;
+declare const SkeletonParagraph: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    width: {
+        type: PropType<widthUnit[] | widthUnit>;
+    };
+    rows: NumberConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    width: {
+        type: PropType<widthUnit[] | widthUnit>;
+    };
+    rows: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default SkeletonParagraph;

package/dist/src/skeleton/Skeleton.d.ts

@@ -0,0 +1,106 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { SkeletonAvatarProps as AvatarProps } from './Avatar';
+import { SkeletonParagraphProps } from './Paragraph';
+import { SkeletonTitleProps } from './Title';
+import { VueNode } from '../_util/type';
+type SkeletonAvatarProps = Omit<AvatarProps, 'active'>;
+export declare const skeletonProps: () => {
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+    avatar: {
+        type: PropType<SkeletonAvatarProps | boolean>;
+        default: SkeletonAvatarProps | boolean;
+    };
+    title: {
+        type: PropType<SkeletonTitleProps | boolean>;
+        default: SkeletonTitleProps | boolean;
+    };
+    paragraph: {
+        type: PropType<SkeletonParagraphProps | boolean>;
+        default: SkeletonParagraphProps | boolean;
+    };
+    round: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export type SkeletonProps = Partial<ExtractPropTypes<ReturnType<typeof skeletonProps>>>;
+declare const Skeleton: DefineComponent<ExtractPropTypes<{
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+    avatar: {
+        type: PropType<SkeletonAvatarProps | boolean>;
+        default: SkeletonAvatarProps | boolean;
+    };
+    title: {
+        type: PropType<SkeletonTitleProps | boolean>;
+        default: SkeletonTitleProps | boolean;
+    };
+    paragraph: {
+        type: PropType<SkeletonParagraphProps | boolean>;
+        default: SkeletonParagraphProps | boolean;
+    };
+    round: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+    avatar: {
+        type: PropType<SkeletonAvatarProps | boolean>;
+        default: SkeletonAvatarProps | boolean;
+    };
+    title: {
+        type: PropType<SkeletonTitleProps | boolean>;
+        default: SkeletonTitleProps | boolean;
+    };
+    paragraph: {
+        type: PropType<SkeletonParagraphProps | boolean>;
+        default: SkeletonParagraphProps | boolean;
+    };
+    round: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    title: boolean | Partial<ExtractPropTypes<{
+        prefixCls: StringConstructor;
+        width: {
+            type: PropType<string | number>;
+        };
+    }>>;
+    round: boolean;
+    active: boolean;
+    loading: boolean;
+    avatar: boolean | SkeletonAvatarProps;
+    paragraph: boolean | Partial<ExtractPropTypes<{
+        prefixCls: StringConstructor;
+        width: {
+            type: PropType<(string | number)[] | (string | number)>;
+        };
+        rows: NumberConstructor;
+    }>>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default Skeleton;

package/dist/src/skeleton/Title.d.ts

@@ -0,0 +1,20 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export declare const skeletonTitleProps: () => {
+    prefixCls: StringConstructor;
+    width: {
+        type: PropType<string | number>;
+    };
+};
+export type SkeletonTitleProps = Partial<ExtractPropTypes<ReturnType<typeof skeletonTitleProps>>>;
+declare const SkeletonTitle: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    width: {
+        type: PropType<string | number>;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    width: {
+        type: PropType<string | number>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default SkeletonTitle;

package/dist/src/skeleton/index.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from 'vue';
+import { default as SkeletonAvatar } from './Avatar';
+import { default as SkeletonButton } from './Button';
+import { default as SkeletonImage } from './Image';
+import { default as SkeletonInput } from './Input';
+import { default as Skeleton } from './Skeleton';
+import { default as SkeletonTitle } from './Title';
+export type { SkeletonButtonProps } from './Button';
+export type { SkeletonInputProps } from './Input';
+export type { SkeletonImageProps } from './Image';
+export type { SkeletonAvatarProps } from './Avatar';
+export type { SkeletonTitleProps } from './Title';
+export type { SkeletonProps } from './Skeleton';
+export { skeletonProps } from './Skeleton';
+export { SkeletonAvatar, SkeletonButton, SkeletonImage, SkeletonInput, SkeletonTitle };
+declare const _default: typeof Skeleton & Plugin & {
+    readonly Button: typeof SkeletonButton;
+    readonly Avatar: typeof SkeletonAvatar;
+    readonly Input: typeof SkeletonInput;
+    readonly Image: typeof SkeletonImage;
+};
+export default _default;

package/dist/src/skeleton/style/index.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { UseComponentStyleResult } from '../../theme/internal';
+export interface ComponentToken {
+    color: string;
+    colorGradientEnd: string;
+}
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;