@antsoo-lib/components 0.0.1

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

@@ -0,0 +1,58 @@
+import { CSSProperties } from 'vue';
+import { Key, VueNode } from '../_util/type';
+import { NotificationInstance } from '../vc-notification/Notification';
+import { default as useMessage } from './useMessage';
+export declare function getKeyThenIncreaseKey(): number;
+export interface ConfigOptions {
+    top?: string;
+    duration?: number;
+    prefixCls?: string;
+    getContainer?: () => HTMLElement;
+    transitionName?: string;
+    maxCount?: number;
+    rtl?: boolean;
+}
+export type NoticeType = 'info' | 'success' | 'error' | 'warning' | 'loading';
+export interface ThenableArgument {
+    (val: any): void;
+}
+export declare const typeList: NoticeType[];
+export interface MessageType extends PromiseLike<any> {
+    (): void;
+}
+export interface MessageArgsProps {
+    content: string | (() => VueNode) | VueNode;
+    duration?: number;
+    type?: NoticeType;
+    prefixCls?: string;
+    rootPrefixCls?: string;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    onClose?: () => void;
+    icon?: (() => VueNode) | VueNode;
+    key?: string | number;
+    style?: CSSProperties;
+    class?: string;
+    appContext?: any;
+    onClick?: (e: MouseEvent) => void;
+}
+type ConfigDuration = number;
+type JointContent = VueNode | MessageArgsProps;
+export type ConfigOnClose = () => void;
+export declare function attachTypeApi(originalApi: MessageApi, type: NoticeType): void;
+export interface MessageInstance {
+    info: (content: JointContent, duration?: ConfigDuration, onClose?: ConfigOnClose) => MessageType;
+    success: (content: JointContent, duration?: ConfigDuration, onClose?: ConfigOnClose) => MessageType;
+    error: (content: JointContent, duration?: ConfigDuration, onClose?: ConfigOnClose) => MessageType;
+    warning: (content: JointContent, duration?: ConfigDuration, onClose?: ConfigOnClose) => MessageType;
+    loading: (content: JointContent, duration?: ConfigDuration, onClose?: ConfigOnClose) => MessageType;
+    open: (args: MessageArgsProps) => MessageType;
+    useMessage: typeof useMessage;
+}
+export interface MessageApi extends MessageInstance {
+    warn: (content: JointContent, duration?: ConfigDuration, onClose?: ConfigOnClose) => MessageType;
+    config: (options: ConfigOptions) => void;
+    destroy: (messageKey?: Key) => void;
+}
+export declare const getInstance: () => NotificationInstance | null;
+declare const _default: MessageApi;
+export default _default;

package/dist/src/message/interface.d.ts

@@ -0,0 +1,38 @@
+import { CSSProperties } from 'vue';
+import { Key, VueNode } from '../_util/type';
+export type NoticeType = 'info' | 'success' | 'error' | 'warning' | 'loading';
+export interface ConfigOptions {
+    top?: number | string;
+    duration?: number;
+    prefixCls?: string;
+    getContainer?: () => HTMLElement;
+    transitionName?: string;
+    maxCount?: number;
+    rtl?: boolean;
+}
+export interface ArgsProps {
+    content: string | (() => VueNode) | VueNode;
+    duration?: number;
+    type?: NoticeType;
+    onClose?: () => void;
+    icon?: (() => VueNode) | VueNode;
+    key?: string | number;
+    style?: CSSProperties;
+    class?: string;
+    onClick?: (e: Event) => void;
+}
+export type JointContent = VueNode | ArgsProps;
+export interface MessageType extends PromiseLike<boolean> {
+    (): void;
+}
+export type TypeOpen = (content: JointContent, duration?: number | VoidFunction, // Also can use onClose directly
+onClose?: VoidFunction) => MessageType;
+export interface MessageInstance {
+    info: TypeOpen;
+    success: TypeOpen;
+    error: TypeOpen;
+    warning: TypeOpen;
+    loading: TypeOpen;
+    open: (args: ArgsProps) => MessageType;
+    destroy: (key?: Key) => void;
+}

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

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+import { UseComponentStyleResult } from '../../theme/internal';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+    height: number;
+    zIndexPopup: number;
+}
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/message/useMessage.d.ts

@@ -0,0 +1,8 @@
+import { VNode } from 'vue';
+import { ConfigOptions, MessageInstance } from './interface';
+type HolderProps = ConfigOptions & {
+    onAllRemoved?: VoidFunction;
+};
+export declare function useInternalMessage(messageConfig?: HolderProps): readonly [MessageInstance, () => VNode];
+export default function useMessage(messageConfig?: ConfigOptions): readonly [MessageInstance, () => VNode];
+export {};

package/dist/src/modal/ConfirmDialog.d.ts

@@ -0,0 +1,12 @@
+import { ModalFuncProps, ModalLocale } from './Modal';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface ConfirmDialogProps extends ModalFuncProps {
+    afterClose?: () => void;
+    close?: (...args: any[]) => void;
+    autoFocusButton?: null | 'ok' | 'cancel';
+    rootPrefixCls: string;
+    iconPrefixCls?: string;
+    locale?: ModalLocale;
+}
+declare const _default: DefineComponent<ConfirmDialogProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ConfirmDialogProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/modal/confirm.d.ts

@@ -0,0 +1,17 @@
+import { ModalFuncProps } from './Modal';
+type ConfigUpdate = ModalFuncProps | ((prevConfig: ModalFuncProps) => ModalFuncProps);
+export type ModalStaticFunctions<T = ModalFunc> = Record<NonNullable<ModalFuncProps['type']>, T>;
+export type ModalFunc = (props: ModalFuncProps) => {
+    destroy: () => void;
+    update: (configUpdate: ConfigUpdate) => void;
+};
+declare const confirm: (config: ModalFuncProps) => {
+    destroy: (this: /*elided*/ any, ...args: any[]) => void;
+    update: (configUpdate: ConfigUpdate) => void;
+};
+export default confirm;
+export declare function withWarn(props: ModalFuncProps): ModalFuncProps;
+export declare function withInfo(props: ModalFuncProps): ModalFuncProps;
+export declare function withSuccess(props: ModalFuncProps): ModalFuncProps;
+export declare function withError(props: ModalFuncProps): ModalFuncProps;
+export declare function withConfirm(props: ModalFuncProps): ModalFuncProps;

package/dist/src/modal/destroyFns.d.ts

@@ -0,0 +1,2 @@
+declare const destroyFns: Array<Function>;
+export default destroyFns;

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

@@ -0,0 +1,18 @@
+import { Plugin } from 'vue';
+import { ModalFunc, default as Modal } from './Modal';
+import { default as useModal } from './useModal';
+export type { ActionButtonProps } from '../_util/ActionButton';
+export type { ModalFuncProps, ModalProps } from './Modal';
+declare const _default: typeof Modal & Plugin & {
+    readonly info: ModalFunc;
+    readonly success: ModalFunc;
+    readonly error: ModalFunc;
+    readonly warn: ModalFunc;
+    readonly warning: ModalFunc;
+    readonly confirm: ModalFunc;
+    readonly addDestroyFn: (fn: () => void) => void;
+    readonly delDestroyFn: (fn: () => void) => void;
+    readonly destroyAll: () => void;
+    readonly useModal: typeof useModal;
+};
+export default _default;

package/dist/src/modal/locale.d.ts

@@ -0,0 +1,7 @@
+export interface ModalLocale {
+    okText: string;
+    cancelText: string;
+    justOkText: string;
+}
+export declare function changeConfirmLocale(newLocale?: ModalLocale): void;
+export declare function getConfirmLocale(): ModalLocale;

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

@@ -0,0 +1,33 @@
+import { AliasToken, FullToken, GenerateStyle, UseComponentStyleResult } from '../../theme/internal';
+import { TokenWithCommonCls } from '../../theme/util/genComponentStyleHook';
+import { Ref } from 'vue';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+}
+export interface ModalToken extends FullToken<'Modal'> {
+    modalBodyPadding: number;
+    modalHeaderBg: string;
+    modalHeaderPadding: string;
+    modalHeaderBorderWidth: number;
+    modalHeaderBorderStyle: string;
+    modalHeaderTitleLineHeight: number;
+    modalHeaderTitleFontSize: number;
+    modalHeaderBorderColorSplit: string;
+    modalHeaderCloseSize: number;
+    modalContentBg: string;
+    modalHeadingColor: string;
+    modalCloseColor: string;
+    modalCloseBtnSize: number;
+    modalFooterBg: string;
+    modalFooterBorderColorSplit: string;
+    modalFooterBorderStyle: string;
+    modalFooterPaddingVertical: number;
+    modalFooterPaddingHorizontal: number;
+    modalFooterBorderWidth: number;
+    modalConfirmTitleFontSize: number;
+    modalIconHoverColor: string;
+    modalConfirmIconSize: number;
+}
+export declare const genModalMaskStyle: GenerateStyle<TokenWithCommonCls<AliasToken>>;
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/modal/useModal/HookModal.d.ts

@@ -0,0 +1,26 @@
+import { ModalFuncProps } from '../Modal';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface HookModalProps {
+    afterClose: () => void;
+    config: ModalFuncProps;
+    destroyAction: (...args: any[]) => void;
+    open: boolean;
+}
+export interface HookModalRef {
+    destroy: () => void;
+    update: (config: ModalFuncProps) => void;
+}
+declare const _default: DefineComponent<{
+    afterClose: () => void;
+    config: ModalFuncProps;
+    destroyAction: (...args: any[]) => void;
+    open: boolean;
+}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+    afterClose: () => void;
+    config: ModalFuncProps;
+    destroyAction: (...args: any[]) => void;
+    open: boolean;
+}> & Readonly<{}>, {
+    open: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/modal/useModal/index.d.ts

@@ -0,0 +1,12 @@
+import { MaybeRef, VueNode } from '../../_util/type';
+import { ModalFuncProps } from '../Modal';
+import { ModalStaticFunctions } from '../confirm';
+export type ModalFuncWithRef = (props: MaybeRef<ModalFuncProps>) => {
+    destroy: () => void;
+    update: (configUpdate: ModalFuncProps) => void;
+};
+declare function useModal(): readonly [
+    Omit<ModalStaticFunctions<ModalFuncWithRef>, 'warn'>,
+    () => VueNode
+];
+export default useModal;

package/dist/src/notification/PurePanel.d.ts

@@ -0,0 +1,30 @@
+import { VueNode } from '../_util/type';
+import { NoticeProps } from '../vc-notification/Notice';
+import { IconType } from './interface';
+import { VNode, RendererNode, RendererElement, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export declare function getCloseIcon(prefixCls: string, closeIcon?: VueNode): string | number | true | VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}> | (string | number | boolean | void | VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}> | null | undefined)[];
+export interface PureContentProps {
+    prefixCls: string;
+    icon?: VueNode;
+    message?: VueNode;
+    description?: VueNode;
+    btn?: VueNode;
+    type?: IconType;
+}
+export declare const TypeIcon: {
+    info: import("vue/jsx-runtime").JSX.Element;
+    success: import("vue/jsx-runtime").JSX.Element;
+    error: import("vue/jsx-runtime").JSX.Element;
+    warning: import("vue/jsx-runtime").JSX.Element;
+    loading: import("vue/jsx-runtime").JSX.Element;
+};
+export declare function PureContent({ prefixCls, icon, type, message, description, btn, }: PureContentProps): import("vue/jsx-runtime").JSX.Element;
+export interface PurePanelProps extends Omit<NoticeProps, 'prefixCls' | 'eventKey'>, Omit<PureContentProps, 'prefixCls'> {
+    prefixCls?: string;
+}
+declare const _default: DefineComponent<PurePanelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PurePanelProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,55 @@
+import { CSSProperties } from 'vue';
+import { VueNode } from '../_util/type';
+import { NotificationInstance as VCNotificationInstance } from '../vc-notification/Notification';
+import { default as useNotification } from './useNotification';
+export type NotificationPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
+export type IconType = 'success' | 'info' | 'error' | 'warning';
+export interface ConfigProps {
+    top?: string | number;
+    bottom?: string | number;
+    duration?: number;
+    prefixCls?: string;
+    placement?: NotificationPlacement;
+    getContainer?: () => HTMLElement;
+    closeIcon?: VueNode | (() => VueNode);
+    rtl?: boolean;
+    maxCount?: number;
+}
+export interface NotificationArgsProps {
+    message: VueNode | (() => VueNode);
+    description?: VueNode | (() => VueNode);
+    btn?: VueNode | (() => VueNode);
+    key?: string;
+    onClose?: () => void;
+    duration?: number | null;
+    icon?: VueNode | (() => VueNode);
+    placement?: NotificationPlacement;
+    maxCount?: number;
+    style?: CSSProperties;
+    prefixCls?: string;
+    class?: string;
+    readonly type?: IconType;
+    onClick?: () => void;
+    top?: string | number;
+    bottom?: string | number;
+    getContainer?: () => HTMLElement;
+    closeIcon?: VueNode | (() => VueNode);
+    appContext?: any;
+}
+export interface NotificationInstance {
+    success: (args: NotificationArgsProps) => void;
+    error: (args: NotificationArgsProps) => void;
+    info: (args: NotificationArgsProps) => void;
+    warning: (args: NotificationArgsProps) => void;
+    open: (args: NotificationArgsProps) => void;
+}
+export interface NotificationApi extends NotificationInstance {
+    warn: (args: NotificationArgsProps) => void;
+    close: (key: string) => void;
+    config: (options: ConfigProps) => void;
+    destroy: () => void;
+    useNotification: typeof useNotification;
+}
+export declare const getInstance: (cacheKey: string) => Promise<VCNotificationInstance | null>;
+declare const _default: NotificationApi;
+export default _default;

package/dist/src/notification/interface.d.ts

@@ -0,0 +1,49 @@
+import { CSSProperties } from 'vue';
+import { Key, VueNode } from '../_util/type';
+export type NotificationPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
+export type IconType = 'success' | 'info' | 'error' | 'warning';
+export interface ArgsProps {
+    message: (() => VueNode) | VueNode;
+    description?: (() => VueNode) | VueNode;
+    btn?: (() => VueNode) | VueNode;
+    key?: Key;
+    onClose?: () => void;
+    duration?: number | null;
+    icon?: (() => VueNode) | VueNode;
+    placement?: NotificationPlacement;
+    style?: CSSProperties;
+    class?: string;
+    readonly type?: IconType;
+    onClick?: () => void;
+    closeIcon?: (() => VueNode) | VueNode;
+}
+type StaticFn = (args: ArgsProps) => void;
+export interface NotificationInstance {
+    success: StaticFn;
+    error: StaticFn;
+    info: StaticFn;
+    warning: StaticFn;
+    open: StaticFn;
+    destroy: (key?: Key) => void;
+}
+export interface GlobalConfigProps {
+    top?: number | string;
+    bottom?: number | string;
+    duration?: number;
+    prefixCls?: string;
+    getContainer?: () => HTMLElement;
+    placement?: NotificationPlacement;
+    closeIcon?: (() => VueNode) | VueNode;
+    rtl?: boolean;
+    maxCount?: number;
+}
+export interface NotificationConfig {
+    top?: number | string;
+    bottom?: number | string;
+    prefixCls?: string;
+    getContainer?: () => HTMLElement;
+    placement?: NotificationPlacement;
+    maxCount?: number;
+    rtl?: boolean;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { FullToken, UseComponentStyleResult } from '../../theme/internal';
+import { Ref } from 'vue';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+    zIndexPopup: number;
+    width: number;
+}
+export interface NotificationToken extends FullToken<'Notification'> {
+    notificationBg: string;
+    notificationPaddingVertical: number;
+    notificationPaddingHorizontal: number;
+    notificationPadding: string;
+    notificationMarginBottom: number;
+    notificationMarginEdge: number;
+    animationMaxHeight: number;
+    notificationIconSize: number;
+    notificationCloseButtonSize: number;
+}
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/notification/style/placement.d.ts

@@ -0,0 +1,5 @@
+import { NotificationToken } from '.';
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+declare const genNotificationPlacementStyle: GenerateStyle<NotificationToken, CSSObject>;
+export default genNotificationPlacementStyle;

package/dist/src/notification/useNotification.d.ts

@@ -0,0 +1,9 @@
+import { VNode } from 'vue';
+import { NotificationConfig, NotificationInstance } from './interface';
+type HolderProps = NotificationConfig & {
+    onAllRemoved?: VoidFunction;
+    getPopupContainer?: () => HTMLElement;
+};
+export declare function useInternalNotification(notificationConfig?: HolderProps): readonly [NotificationInstance, () => VNode];
+export default function useNotification(notificationConfig?: NotificationConfig): readonly [NotificationInstance, () => VNode];
+export {};

package/dist/src/notification/util.d.ts

@@ -0,0 +1,5 @@
+import { CSSProperties } from 'vue';
+import { CSSMotionProps } from '../_util/transition';
+import { NotificationPlacement } from './interface';
+export declare function getPlacementStyle(placement: NotificationPlacement, top: number | string, bottom: number | string): CSSProperties;
+export declare function getMotion(prefixCls: string): CSSMotionProps;

package/dist/src/page-header/style/index.d.ts

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