mc-plus 1.0.7 → 1.0.9

package/dist/types/components/mc-table/composables/useTableScroll.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { TableColumn } from '../types';
+export declare function useTableScroll(columns: Ref<TableColumn[]>, headerRef: Ref<{
+    headerWrapper?: HTMLDivElement;
+} | undefined>, bodyRef: Ref<{
+    bodyWrapper?: HTMLDivElement;
+} | undefined>): {
+    hasHorizontalScroll: Ref<boolean, boolean>;
+    columnsWithFixed: import('vue').ComputedRef<TableColumn[]>;
+    checkHorizontalScroll: () => void;
+    syncHeaderScroll: () => void;
+    initScrollSync: () => void;
+};

package/dist/types/components/mc-table/composables/useTableSort.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { SortConfig, SortOrder, TableColumn } from '../types';
+export declare function useTableSort(data: Ref<Record<string, unknown>[]>, columns: Ref<TableColumn[]>, defaultSort?: SortConfig): {
+    sortedData: import('vue').ComputedRef<Record<string, unknown>[]>;
+    currentSort: Ref<{
+        prop: string;
+        order: SortOrder;
+    } | null, SortConfig | {
+        prop: string;
+        order: SortOrder;
+    } | null>;
+    handleSort: (column: TableColumn) => {
+        prop: string;
+        order: SortOrder;
+    } | null | undefined;
+    getSortOrder: (prop: string) => SortOrder;
+};

package/dist/types/components/mc-table/index.d.ts

@@ -0,0 +1,7 @@
+import { default as McTable } from './mc-table.vue';
+export { McTable };
+export default McTable;
+export * from './composables/usePagination';
+export * from './composables/useTableScroll';
+export * from './composables/useTableSort';
+export * from './types';

package/dist/types/components/mc-table/types.d.ts

@@ -0,0 +1,168 @@
+import { Ref } from 'vue';
+export type RowData = Record<string, unknown>;
+export type SortDirection = "asc" | "desc";
+export type SortOrder = SortDirection | null;
+export type AlignType = "left" | "center" | "right";
+export type ColumnFixed = boolean | "left" | "right";
+export interface TableProps {
+    data: RowData[];
+    columns: TableColumn[];
+    showHeader?: boolean;
+    height?: string | number;
+    maxHeight?: string | number;
+    rowKey?: string;
+    emptyText?: string;
+    pagination?: PaginationConfig;
+    loading?: boolean;
+    loadingText?: string;
+    loadingConfig?: LoadingConfig;
+    highlightCurrentRow?: boolean;
+    selectable?: boolean;
+    selectedRows?: RowData[];
+    selectOnRowClick?: boolean;
+    spanMethod?: (params: {
+        row: RowData;
+        column: TableColumn;
+        rowIndex: number;
+        columnIndex: number;
+    }) => {
+        rowspan?: number;
+        colspan?: number;
+    } | [number, number];
+    initData?: (params: {
+        pageSize: number;
+        pageNum: number;
+    }) => Promise<{
+        data: RowData[];
+        total: number;
+    }>;
+    defaultSort?: SortConfig;
+}
+export interface PaginationConfig {
+    currentPage?: number;
+    pageSize?: number;
+    total: number;
+    pageSizes?: number[];
+    background?: boolean;
+}
+export interface LoadingConfig {
+    text?: string;
+    spinner?: string;
+    background?: string;
+    customClass?: string;
+}
+export interface SortConfig {
+    prop: string;
+    order: SortOrder;
+}
+export interface TableColumn {
+    prop: string;
+    label: string;
+    width?: number | string;
+    fixed?: ColumnFixed;
+    formatter?: (row: RowData, column: TableColumn, cellValue: unknown, index: number) => unknown;
+    align?: AlignType;
+    headerAlign?: AlignType;
+    className?: string;
+    headerClassName?: string;
+    slot?: string;
+    colSpan?: number | ((row: RowData, column: TableColumn, index: number) => number);
+    rowSpan?: number | ((row: RowData, column: TableColumn, index: number) => number);
+    sortable?: boolean;
+    sortOrder?: SortOrder;
+    sortMethod?: (a: unknown, b: unknown) => number;
+}
+export interface TableEmits {
+    (e: "row-click", row: RowData, index: number): void;
+    (e: "header-click", column: TableColumn, event: Event): void;
+    (e: "page-change", payload: {
+        pageSize: number;
+        pageNum: number;
+    }): void;
+    (e: "page-size-change", pageSize: number): void;
+    (e: "sort-change", config: SortConfig): void;
+    (e: "current-change", currentRow: RowData | null): void;
+    (e: "selection-change", selectedRows: RowData[]): void;
+    (e: "select", row: RowData, selected: boolean): void;
+    (e: "select-all", selected: boolean): void;
+    (e: "update:selectedRows", selectedRows: RowData[]): void;
+}
+export interface CellSlotProps {
+    row: RowData;
+    column: TableColumn;
+    $index: number;
+    value: unknown;
+    prop: string;
+}
+export interface HeaderSlotProps {
+    column: TableColumn;
+    index: number;
+}
+export interface TableInstance {
+    ref: Ref<HTMLElement | undefined>;
+    refresh: () => Promise<void>;
+    clearSort: () => void;
+    toggleRowSelection: (row: RowData, selected?: boolean) => void;
+    toggleAllSelection: (selected: boolean) => void;
+    clearSelection: () => void;
+    getSelectedRows: () => RowData[];
+}
+export interface TableCellProps {
+    row: Record<string, unknown>;
+    column: TableColumn;
+    rowIndex: number;
+    columnIndex: number;
+    pagination?: {
+        currentPage?: number;
+        pageSize?: number;
+        total: number;
+    };
+    spanMethod?: (data: {
+        row: Record<string, unknown>;
+        column: TableColumn;
+        rowIndex: number;
+        columnIndex: number;
+    }) => {
+        rowspan?: number;
+        colspan?: number;
+    } | [number, number];
+}
+export interface McTableHeaderProps {
+    columns: TableColumn[];
+    showHeader?: boolean;
+    getSortOrder?: (prop: string) => SortOrder;
+    selectable?: boolean;
+    isAllSelected?: boolean;
+    isIndeterminate?: boolean;
+}
+export interface TableHeaderEmits {
+    (e: "header-click", column: TableColumn, event: Event): void;
+    (e: "sort-change", column: TableColumn): void;
+    (e: "select-all", selected: boolean): void;
+}
+export interface McTableBodyProps {
+    data: Record<string, unknown>[];
+    columns: TableColumn[];
+    rowKey?: string;
+    emptyText?: string;
+    height?: string | number;
+    maxHeight?: string | number;
+    pagination?: PaginationConfig;
+    spanMethod?: (data: {
+        row: Record<string, unknown>;
+        column: TableColumn;
+        rowIndex: number;
+        columnIndex: number;
+    }) => {
+        rowspan?: number;
+        colspan?: number;
+    } | [number, number];
+    getRowClass?: (row: Record<string, unknown>, index: number) => string[];
+    selectable?: boolean;
+    selectedRows?: RowData[];
+    selectOnRowClick?: boolean;
+}
+export interface TableBodyEmits {
+    (e: "row-click", row: Record<string, unknown>, index: number): void;
+    (e: "select", row: RowData, selected: boolean): void;
+}

package/dist/types/components/mc-tag/index.d.ts

@@ -0,0 +1,60 @@
+export * from './types';
+export declare const McTag: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').TagProps> & Readonly<{
+        onClick?: ((val: MouseEvent) => any) | undefined;
+        onClose?: ((val: MouseEvent) => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        click: (val: MouseEvent) => any;
+        close: (val: MouseEvent) => any;
+    }, import('vue').PublicProps, {
+        size: import('../../core').TagSize;
+        type: import('../../core').TagType;
+        closable: boolean;
+        disabled: boolean;
+        radius: import('../../core').TagRadius;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').TagProps> & Readonly<{
+        onClick?: ((val: MouseEvent) => any) | undefined;
+        onClose?: ((val: MouseEvent) => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | void>;
+    }, {}, {}, {}, {
+        size: import('../../core').TagSize;
+        type: import('../../core').TagType;
+        closable: boolean;
+        disabled: boolean;
+        radius: import('../../core').TagRadius;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').TagProps> & Readonly<{
+    onClick?: ((val: MouseEvent) => any) | undefined;
+    onClose?: ((val: MouseEvent) => any) | undefined;
+}>, {
+    ref: import('vue').Ref<HTMLDivElement | void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (val: MouseEvent) => any;
+    close: (val: MouseEvent) => any;
+}, string, {
+    size: import('../../core').TagSize;
+    type: import('../../core').TagType;
+    closable: boolean;
+    disabled: boolean;
+    radius: import('../../core').TagRadius;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export default McTag;

package/dist/types/components/mc-tag/types.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { IconType } from '../mc-icon/types';
+export type TagType = "primary" | "plain";
+export type TagSize = "medium" | "large" | "small";
+export type TagRadius = "default" | "round" | "circle" | "square";
+export interface TagProps {
+    type?: TagType;
+    size?: TagSize;
+    disabled?: boolean;
+    closable?: boolean;
+    color?: string;
+    textColor?: string;
+    backgroundColor?: string;
+    selectedTextColor?: string;
+    selectedBackgroundColor?: string;
+    radius?: TagRadius;
+    height?: string;
+    width?: string;
+    icon?: IconType;
+    selected?: boolean;
+}
+export interface TagEmits {
+    (e: "click", val: MouseEvent): void;
+    (e: "close", val: MouseEvent): void;
+}
+export interface TagInstance {
+    ref: Ref<HTMLDivElement | void>;
+}

package/dist/types/components/mc-toast/index.d.ts

@@ -0,0 +1,61 @@
+export * from './toast';
+export * from './types';
+export declare const McToast: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').ToastProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | void>;
+        close: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        close: () => any;
+    }, import('vue').PublicProps, {
+        title: string;
+        type: import('../../core').ToastType;
+        message: string;
+        duration: number;
+        showClose: boolean;
+        position: import('../../core').ToastPosition;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').ToastProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | void>;
+        close: () => void;
+    }, {}, {}, {}, {
+        title: string;
+        type: import('../../core').ToastType;
+        message: string;
+        duration: number;
+        showClose: boolean;
+        position: import('../../core').ToastPosition;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').ToastProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    ref: import('vue').Ref<HTMLDivElement | void>;
+    close: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, {
+    title: string;
+    type: import('../../core').ToastType;
+    message: string;
+    duration: number;
+    showClose: boolean;
+    position: import('../../core').ToastPosition;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+declare const _default: {
+    install: (app: any) => void;
+};
+export default _default;

package/dist/types/components/mc-toast/toast.d.ts

@@ -0,0 +1,19 @@
+import { ToastProps } from './types';
+export declare const createToast: (options: ToastProps | string) => {
+    close: () => void;
+};
+export declare const toast: (options: ToastProps | string) => {
+    close: () => void;
+};
+export declare const toastPrimary: (options: ToastProps | string) => {
+    close: () => void;
+};
+export declare const toastSuccess: (options: ToastProps | string) => {
+    close: () => void;
+};
+export declare const toastWarning: (options: ToastProps | string) => {
+    close: () => void;
+};
+export declare const toastError: (options: ToastProps | string) => {
+    close: () => void;
+};

package/dist/types/components/mc-toast/types.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { IconType } from '../mc-icon/types';
+export type ToastType = "primary" | "success" | "warning" | "error" | "info";
+export type ToastPosition = "top" | "bottom";
+export interface ToastProps {
+    type?: ToastType;
+    title?: string;
+    message?: string;
+    icon?: IconType;
+    showClose?: boolean;
+    duration?: number;
+    position?: ToastPosition;
+    onClose?: () => void;
+}
+export interface ToastEmits {
+    (e: "close"): void;
+}
+export interface ToastInstance {
+    ref: Ref<HTMLDivElement | void>;
+    close: () => void;
+}

package/dist/types/components/mc-tooltip/index.d.ts

@@ -0,0 +1,65 @@
+export * from './types';
+export declare const McTooltip: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').TooltipProps> & Readonly<{
+        "onVisible:change"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: (() => any) | undefined;
+    }>, {
+        show(): void;
+        hide(): void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "visible:change": (value: boolean) => any;
+        "click:outside": () => any;
+    }, import('vue').PublicProps, {
+        trigger: import('../../core').TooltipTrigger;
+        placement: import('@popperjs/core').Placement;
+        showTimeout: number;
+        hideTimeout: number;
+        transitionName: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        containerNode: HTMLDivElement;
+        triggerNode: HTMLDivElement;
+        popperNode: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').TooltipProps> & Readonly<{
+        "onVisible:change"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: (() => any) | undefined;
+    }>, {
+        show(): void;
+        hide(): void;
+    }, {}, {}, {}, {
+        trigger: import('../../core').TooltipTrigger;
+        placement: import('@popperjs/core').Placement;
+        showTimeout: number;
+        hideTimeout: number;
+        transitionName: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').TooltipProps> & Readonly<{
+    "onVisible:change"?: ((value: boolean) => any) | undefined;
+    "onClick:outside"?: (() => any) | undefined;
+}>, {
+    show(): void;
+    hide(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "visible:change": (value: boolean) => any;
+    "click:outside": () => any;
+}, string, {
+    trigger: import('../../core').TooltipTrigger;
+    placement: import('@popperjs/core').Placement;
+    showTimeout: number;
+    hideTimeout: number;
+    transitionName: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+}) & import('vue').Plugin;

package/dist/types/components/mc-tooltip/types.d.ts

@@ -0,0 +1,20 @@
+import { Placement, Options } from '@popperjs/core';
+export type TooltipTrigger = "hover" | "click";
+export interface TooltipProps {
+    content?: string;
+    trigger?: TooltipTrigger;
+    placement?: Placement;
+    disabled?: boolean;
+    popperOptions?: Partial<Options>;
+    showTimeout?: number;
+    hideTimeout?: number;
+    transitionName?: string;
+}
+export interface TooltipEmits {
+    (e: "visible:change", value: boolean): void;
+    (e: "click:outside"): void;
+}
+export interface TooltipInstance {
+    show(): void;
+    hide(): void;
+}

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useClickOutside } from './useClickOutside';
+export { default as useEventListener } from './useEventListener';

package/dist/types/hooks/useClickOutside.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useClickOutside(elementRef: Ref<HTMLElement | void>, callback: (e: MouseEvent) => void): void;

package/dist/types/hooks/useEventListener.d.ts

@@ -0,0 +1,2 @@
+import { MaybeRef } from 'vue';
+export default function useEventListener(target: MaybeRef<EventTarget | HTMLElement | void>, event: string, handler: (e: Event) => any): void;