@antsoo-lib/components 0.0.1

package/dist/src/vc-table/context/SummaryContext.d.ts

@@ -0,0 +1,14 @@
+import { InjectionKey } from 'vue';
+import { ColumnType, StickyOffsets } from '../interface';
+export type FlattenColumns<RecordType> = readonly (ColumnType<RecordType> & {
+    scrollbar?: boolean;
+})[];
+interface SummaryContextProps {
+    stickyOffsets?: StickyOffsets;
+    scrollColumnIndex?: number;
+    flattenColumns?: FlattenColumns<any>;
+}
+export declare const SummaryContextKey: InjectionKey<SummaryContextProps>;
+export declare const useProvideSummary: (props: SummaryContextProps) => void;
+export declare const useInjectSummary: () => SummaryContextProps;
+export {};

package/dist/src/vc-table/context/TableContext.d.ts

@@ -0,0 +1,16 @@
+import { InjectionKey } from 'vue';
+import { GetComponent, TransformCellText } from '../interface';
+import { FixedInfo } from '../utils/fixUtil';
+export interface TableContextProps {
+    prefixCls: string;
+    getComponent: GetComponent;
+    scrollbarSize: number;
+    direction: 'ltr' | 'rtl';
+    fixedInfoList: readonly FixedInfo[];
+    isSticky: boolean;
+    summaryCollect: (uniKey: string, fixed: boolean | string) => void;
+    transformCellText: TransformCellText<unknown>;
+}
+export declare const TableContextKey: InjectionKey<TableContextProps>;
+export declare const useProvideTable: (props: TableContextProps) => void;
+export declare const useInjectTable: () => TableContextProps;

package/dist/src/vc-table/hooks/useColumns.d.ts

@@ -0,0 +1,21 @@
+import { ComputedRef, Ref } from 'vue';
+import { ColumnType, ColumnsType, FixedType, GetRowKey, Key, RenderExpandIcon, TriggerEventHandler } from '../interface';
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+declare function useColumns<RecordType>({ prefixCls, columns: baseColumns, expandable, expandedKeys, getRowKey, onTriggerExpand, expandIcon, rowExpandable, expandIconColumnIndex, direction, expandRowByClick, expandColumnWidth, expandFixed, }: {
+    prefixCls?: Ref<string>;
+    columns?: Ref<ColumnsType<RecordType>>;
+    expandable: Ref<boolean>;
+    expandedKeys: ComputedRef<Set<Key>>;
+    getRowKey: Ref<GetRowKey<RecordType>>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIcon?: Ref<RenderExpandIcon<RecordType>>;
+    rowExpandable?: Ref<(record: RecordType) => boolean>;
+    expandIconColumnIndex?: Ref<number>;
+    direction?: Ref<'ltr' | 'rtl'>;
+    expandRowByClick?: Ref<boolean>;
+    expandColumnWidth?: Ref<number | string>;
+    expandFixed?: Ref<FixedType>;
+}, transformColumns: Ref<(columns: ColumnsType<RecordType>) => ColumnsType<RecordType>>): [ComputedRef<ColumnsType<RecordType>>, ComputedRef<readonly ColumnType<RecordType>[]>];
+export default useColumns;

package/dist/src/vc-table/hooks/useFlattenRecords.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+import { GetRowKey, Key } from '../interface';
+/**
+ * flat tree data on expanded state
+ *
+ * @export
+ * @template T
+ * @param {*} data : table data
+ * @param {string} childrenColumnName : 指定树形结构的列名
+ * @param {Set<Key>} expandedKeys : 展开的行对应的keys
+ * @param {GetRowKey<T>} getRowKey  : 获取当前rowKey的方法
+ * @returns flattened data
+ */
+export default function useFlattenRecords<T = unknown>(dataRef: Ref<T[]>, childrenColumnNameRef: Ref<string>, expandedKeysRef: Ref<Set<Key>>, getRowKey: Ref<GetRowKey<T>>): Ref<{
+    record: T;
+    indent: number;
+    index: number;
+}[], {
+    record: T;
+    indent: number;
+    index: number;
+}[]>;

package/dist/src/vc-table/hooks/useFrame.d.ts

@@ -0,0 +1,5 @@
+import { Ref, UnwrapRef } from 'vue';
+export type Updater<State> = (prev: State) => State;
+export declare function useLayoutState<State>(defaultState: State): [Ref<State>, (updater: Updater<State>) => void];
+/** Lock frame, when frame pass reset the lock. */
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: UnwrapRef<State>) => void, () => UnwrapRef<State> | null];

package/dist/src/vc-table/hooks/useSticky.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef, Ref } from 'vue';
+import { TableSticky } from '../interface';
+/** Sticky header hooks */
+export default function useSticky(stickyRef: Ref<boolean | TableSticky>, prefixClsRef: Ref<string>): ComputedRef<{
+    isSticky: boolean;
+    offsetHeader: number;
+    offsetSummary: number;
+    offsetScroll: number;
+    stickyClassName: string;
+    container: Window | HTMLElement;
+}>;

package/dist/src/vc-table/hooks/useStickyOffsets.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef, Ref } from 'vue';
+import { StickyOffsets } from '../interface';
+/**
+ * Get sticky column offset width
+ */
+declare function useStickyOffsets(colWidthsRef: Ref<number[]>, columnCountRef: Ref<number>, directionRef: Ref<'ltr' | 'rtl'>): ComputedRef<StickyOffsets>;
+export default useStickyOffsets;

package/dist/src/vc-table/index.d.ts

@@ -0,0 +1,8 @@
+import { FooterComponents as Summary, SummaryCell, SummaryRow } from './Footer';
+import { default as Table } from './Table';
+import { EXPAND_COLUMN } from './constant';
+import { default as Column } from './sugar/Column';
+import { default as ColumnGroup } from './sugar/ColumnGroup';
+import { INTERNAL_COL_DEFINE } from './utils/legacyUtil';
+export { Column, ColumnGroup, EXPAND_COLUMN, INTERNAL_COL_DEFINE, Summary, SummaryCell, SummaryRow };
+export default Table;

package/dist/src/vc-table/interface.d.ts

@@ -0,0 +1,177 @@
+import { CSSProperties, Ref, TdHTMLAttributes } from 'vue';
+export type Key = number | string;
+export type FixedType = 'left' | 'right' | boolean;
+export type DefaultRecordType = any;
+export type TableLayout = 'auto' | 'fixed';
+export type RowClassName<RecordType> = (record: RecordType, index: number, indent: number) => string;
+export type TransformCellText<RecordType> = (opt: {
+    text: any;
+    column: ColumnType<RecordType>;
+    record: any;
+    index: number;
+}) => any;
+export interface CellType<RecordType = DefaultRecordType> {
+    key?: Key;
+    class?: string;
+    style?: CSSProperties;
+    column?: ColumnsType<RecordType>[number];
+    colSpan?: number;
+    rowSpan?: number;
+    /** Only used for table header */
+    hasSubColumns?: boolean;
+    colStart?: number;
+    colEnd?: number;
+}
+export interface RenderedCell<RecordType> {
+    props?: CellType<RecordType>;
+    children?: any;
+}
+export type DataIndex = string | number | readonly (string | number)[];
+export type CellEllipsisType = {
+    showTitle?: boolean;
+} | boolean;
+interface ColumnSharedType<RecordType> {
+    title?: any;
+    key?: Key;
+    class?: string;
+    className?: string;
+    fixed?: FixedType;
+    customHeaderCell?: GetComponentProps<ColumnsType<RecordType>[number]>;
+    ellipsis?: CellEllipsisType;
+    align?: AlignType;
+    customFilterDropdown?: boolean;
+    /** @deprecated Please use `v-slot:filterIcon` `v-slot:bodyCell` `v-slot:headerCell` instead */
+    slots?: {
+        filterIcon?: string;
+        filterDropdown?: string;
+        customRender?: string;
+        title?: string;
+    };
+    /**
+     * @private
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    __originColumn__?: any;
+}
+export interface ColumnGroupType<RecordType> extends ColumnSharedType<RecordType> {
+    children: ColumnsType<RecordType>;
+}
+export type AlignType = 'left' | 'center' | 'right';
+export interface ColumnType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    dataIndex?: DataIndex;
+    customRender?: (opt: {
+        value: any;
+        text: any;
+        record: RecordType;
+        index: number;
+        renderIndex: number;
+        column: ColumnType<RecordType>;
+    }) => any | RenderedCell<RecordType>;
+    rowSpan?: number;
+    width?: number | string;
+    minWidth?: number;
+    maxWidth?: number;
+    resizable?: boolean;
+    customCell?: GetComponentProps<RecordType>;
+    /** @deprecated Please use `customCell` instead */
+    onCellClick?: (record: RecordType, e: MouseEvent) => void;
+}
+export type ColumnsType<RecordType = unknown> = readonly (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export type GetRowKey<RecordType> = (record: RecordType, index?: number) => Key;
+export interface StickyOffsets {
+    left: readonly number[];
+    right: readonly number[];
+    isSticky?: boolean;
+}
+export type AdditionalProps = TdHTMLAttributes & {
+    colSpan?: number;
+    rowSpan?: number;
+};
+export type GetComponentProps<DataType> = (data: DataType, index?: number, column?: ColumnType<any>) => AdditionalProps;
+export type CustomizeComponent = any;
+export type CustomizeScrollBody<RecordType> = (data: readonly RecordType[], info: {
+    scrollbarSize: number;
+    ref: Ref<{
+        scrollLeft: number;
+    }>;
+    onScroll: (info: {
+        currentTarget?: HTMLElement;
+        scrollLeft?: number;
+    }) => void;
+}) => any;
+export interface TableComponents<RecordType> {
+    table?: CustomizeComponent;
+    header?: {
+        wrapper?: CustomizeComponent;
+        row?: CustomizeComponent;
+        cell?: CustomizeComponent;
+    };
+    body?: CustomizeScrollBody<RecordType> | {
+        wrapper?: CustomizeComponent;
+        row?: CustomizeComponent;
+        cell?: CustomizeComponent;
+    };
+}
+export type GetComponent = (path: readonly string[], defaultComponent?: CustomizeComponent) => CustomizeComponent;
+export type ExpandableType = false | 'row' | 'nest';
+export interface LegacyExpandableProps<RecordType> {
+    expandedRowKeys?: Key[];
+    defaultExpandedRowKeys?: Key[];
+    expandedRowRender?: ExpandedRowRender<RecordType>;
+    expandRowByClick?: boolean;
+    expandIcon?: RenderExpandIcon<RecordType>;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedKeys: Key[]) => void;
+    defaultExpandAllRows?: boolean;
+    indentSize?: number;
+    /** @deprecated Please use `EXPAND_COLUMN` in `columns` directly */
+    expandIconColumnIndex?: number;
+    showExpandColumn?: boolean;
+    expandedRowClassName?: RowClassName<RecordType>;
+    childrenColumnName?: string;
+    rowExpandable?: (record: RecordType) => boolean;
+}
+export type ExpandedRowRender<ValueType> = (opt: {
+    record: ValueType;
+    index: number;
+    indent: number;
+    expanded: boolean;
+}) => any;
+export interface RenderExpandIconProps<RecordType> {
+    prefixCls: string;
+    expanded: boolean;
+    record: RecordType;
+    expandable: boolean;
+    onExpand: TriggerEventHandler<RecordType>;
+}
+export type RenderExpandIcon<RecordType> = (props: RenderExpandIconProps<RecordType>) => any;
+export interface ExpandableConfig<RecordType> {
+    expandedRowKeys?: readonly Key[];
+    defaultExpandedRowKeys?: readonly Key[];
+    expandedRowRender?: ExpandedRowRender<RecordType>;
+    expandRowByClick?: boolean;
+    expandIcon?: RenderExpandIcon<RecordType>;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedKeys: readonly Key[]) => void;
+    defaultExpandAllRows?: boolean;
+    indentSize?: number;
+    /** @deprecated Please use `EXPAND_COLUMN` in `columns` directly */
+    expandIconColumnIndex?: number;
+    showExpandColumn?: boolean;
+    expandedRowClassName?: RowClassName<RecordType>;
+    childrenColumnName?: string;
+    rowExpandable?: (record: RecordType) => boolean;
+    columnWidth?: number | string;
+    fixed?: FixedType;
+}
+export type PanelRender<RecordType> = (data: readonly RecordType[]) => any;
+export type TriggerEventHandler<RecordType> = (record: RecordType, event: MouseEvent) => void;
+export interface TableSticky {
+    offsetHeader?: number;
+    offsetSummary?: number;
+    offsetScroll?: number;
+    getContainer?: () => Window | HTMLElement;
+}
+export {};

package/dist/src/vc-table/stickyScrollBar.d.ts

@@ -0,0 +1,15 @@
+import { Ref, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface StickyScrollBarProps {
+    scrollBodyRef: Ref<HTMLElement>;
+    onScroll: (params: {
+        scrollLeft?: number;
+    }) => void;
+    offsetScroll: number;
+    container: HTMLElement | Window;
+    scrollBodySizeInfo: {
+        scrollWidth: number;
+        clientWidth: number;
+    };
+}
+declare const _default: DefineComponent<StickyScrollBarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<StickyScrollBarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/vc-table/sugar/Column.d.ts

@@ -0,0 +1,11 @@
+import { FunctionalComponent } from 'vue';
+import { ColumnType } from '../interface';
+export type ColumnProps<RecordType> = ColumnType<RecordType>;
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare const Column: {
+    <T>(arg: T): FunctionalComponent<ColumnProps<T>>;
+};
+export default Column;

package/dist/src/vc-table/sugar/ColumnGroup.d.ts

@@ -0,0 +1,11 @@
+import { FunctionalComponent } from 'vue';
+import { ColumnType } from '../interface';
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+export type ColumnGroupProps<RecordType> = ColumnType<RecordType>;
+declare const ColumnGroup: {
+    <T>(arg: T): FunctionalComponent<ColumnGroupProps<T>>;
+};
+export default ColumnGroup;

package/dist/src/vc-table/utils/expandUtil.d.ts

@@ -0,0 +1,3 @@
+import { GetRowKey, Key, RenderExpandIconProps } from '../interface';
+export declare function renderExpandIcon<RecordType>({ prefixCls, record, onExpand, expanded, expandable, }: RenderExpandIconProps<RecordType>): import("vue/jsx-runtime").JSX.Element;
+export declare function findAllChildrenKeys<RecordType>(data: readonly RecordType[], getRowKey: GetRowKey<RecordType>, childrenColumnName: string): Key[];

package/dist/src/vc-table/utils/fixUtil.d.ts

@@ -0,0 +1,13 @@
+import { FixedType, StickyOffsets } from '../interface';
+export interface FixedInfo {
+    fixLeft: number | false;
+    fixRight: number | false;
+    lastFixLeft: boolean;
+    firstFixRight: boolean;
+    lastFixRight: boolean;
+    firstFixLeft: boolean;
+    isSticky: boolean;
+}
+export declare function getCellFixedInfo(colStart: number, colEnd: number, columns: readonly {
+    fixed?: FixedType;
+}[], stickyOffsets: StickyOffsets, direction: 'ltr' | 'rtl'): FixedInfo;

package/dist/src/vc-table/utils/legacyUtil.d.ts

@@ -0,0 +1,10 @@
+import { ExpandableConfig, LegacyExpandableProps } from '../interface';
+export declare const INTERNAL_COL_DEFINE = "RC_TABLE_INTERNAL_COL_DEFINE";
+export declare function getExpandableProps<RecordType>(props: LegacyExpandableProps<RecordType> & {
+    expandable?: ExpandableConfig<RecordType>;
+}): ExpandableConfig<RecordType>;
+/**
+ * Returns only data- and aria- key/value pairs
+ * @param {object} props
+ */
+export declare function getDataAndAriaProps(props: object): {};

package/dist/src/vc-table/utils/valueUtil.d.ts

@@ -0,0 +1,10 @@
+import { DataIndex, Key } from '../interface';
+export declare function getPathValue<ValueType, ObjectType extends object>(record: ObjectType, path: DataIndex): ValueType;
+interface GetColumnKeyColumn {
+    key?: Key;
+    dataIndex?: DataIndex;
+}
+export declare function getColumnsKey(columns: readonly GetColumnKeyColumn[]): Key[];
+export declare function mergeObject<ReturnObject extends object>(...objects: Partial<ReturnObject>[]): ReturnObject;
+export declare function validateValue<T>(val: T): val is T & {};
+export {};

package/dist/src/vc-tooltip/index.d.ts

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

package/dist/src/vc-tooltip/src/placements.d.ts

@@ -0,0 +1,111 @@
+export declare const placements: {
+    left: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    right: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    top: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    leftTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    topRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    rightTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    rightBottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    leftBottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+};
+export default placements;

package/dist/src/vc-tour/Mask.d.ts

@@ -0,0 +1,93 @@
+import { CSSProperties, DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PosInfo } from './hooks/useTarget';
+export interface MaskProps {
+    prefixCls?: string;
+    pos: PosInfo;
+    rootClassName?: string;
+    showMask?: boolean;
+    style?: CSSProperties;
+    fill?: string;
+    open?: boolean;
+    animated?: boolean | {
+        placeholder: boolean;
+    };
+    zIndex?: number;
+}
+declare const Mask: DefineComponent<ExtractPropTypes<{
+    prefixCls: {
+        type: StringConstructor;
+    };
+    pos: {
+        type: PropType<PosInfo>;
+        default: PosInfo;
+    };
+    rootClassName: {
+        type: StringConstructor;
+    };
+    showMask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animated: {
+        type: PropType<boolean | {
+            placeholder: boolean;
+        }>;
+        default: boolean | {
+            placeholder: boolean;
+        };
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    prefixCls: {
+        type: StringConstructor;
+    };
+    pos: {
+        type: PropType<PosInfo>;
+        default: PosInfo;
+    };
+    rootClassName: {
+        type: StringConstructor;
+    };
+    showMask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animated: {
+        type: PropType<boolean | {
+            placeholder: boolean;
+        }>;
+        default: boolean | {
+            placeholder: boolean;
+        };
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+}>> & Readonly<{}>, {
+    open: boolean;
+    fill: string;
+    pos: PosInfo;
+    showMask: boolean;
+    animated: boolean | {
+        placeholder: boolean;
+    };
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default Mask;