@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/table/Table.vue.d.ts

@@ -0,0 +1,29 @@
+import { TableChangeInfo, TableExposed, TableProps, TableRowKey, TableSlots } from './types';
+type RecordType = Record<string, unknown>;
+type __VLS_Props = TableProps<RecordType>;
+type __VLS_Slots = TableSlots<RecordType>;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, TableExposed<RecordType>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    expand: (expanded: boolean, record: RecordType, event?: MouseEvent | undefined) => any;
+    select: (record: RecordType, selected: boolean, selectedRows: RecordType[], event?: MouseEvent | undefined) => any;
+    change: (changeInfo: TableChangeInfo<RecordType>) => any;
+    selectAll: (selected: boolean, selectedRows: RecordType[], changedRows: RecordType[]) => any;
+    pageChange: (currentPage: number, pageSize: number) => any;
+    expandedRowsChange: (expandedRows: RecordType[]) => any;
+    selectChange: (selectedRowKeys: TableRowKey[], selectedRows: RecordType[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onExpand?: (expanded: boolean, record: RecordType, event?: MouseEvent | undefined) => any;
+    onSelect?: (record: RecordType, selected: boolean, selectedRows: RecordType[], event?: MouseEvent | undefined) => any;
+    onChange?: (changeInfo: TableChangeInfo<RecordType>) => any;
+    onSelectAll?: (selected: boolean, selectedRows: RecordType[], changedRows: RecordType[]) => any;
+    onPageChange?: (currentPage: number, pageSize: number) => any;
+    onExpandedRowsChange?: (expandedRows: RecordType[]) => any;
+    onSelectChange?: (selectedRowKeys: TableRowKey[], selectedRows: RecordType[]) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/table/TableBody.vue.d.ts

@@ -0,0 +1,70 @@
+import { Component, VNodeChild } from 'vue';
+import { FlatTableRecord, NormalizedTableColumn } from './table-utils';
+import { TableDirection, TableRowAttributes, TableRowKey, TableRowSelection } from './types';
+interface Props {
+    clickGroupedRowToExpand?: boolean | undefined;
+    columns: NormalizedTableColumn<Record<string, unknown>>[];
+    componentCell?: Component | string | undefined;
+    componentRow?: Component | string | undefined;
+    componentWrapper?: Component | string | undefined;
+    direction: TableDirection;
+    expandedKeys: ReadonlySet<TableRowKey>;
+    expandIcon?: boolean | VNodeChild | ((expanded?: boolean) => VNodeChild) | undefined;
+    expandedRowRender?: ((record?: Record<string, unknown>, index?: number, expanded?: boolean) => VNodeChild) | undefined;
+    expandRowByClick?: boolean | undefined;
+    fixedOffsets: ReadonlyMap<TableRowKey, {
+        side: 'left' | 'right';
+        value: number;
+        edge: boolean;
+    }>;
+    halfSelectedKeys: ReadonlySet<TableRowKey>;
+    hideExpandedColumn: boolean;
+    indentSize: number;
+    keepDOM?: boolean | undefined;
+    onRow?: ((record?: Record<string, unknown>, index?: number, status?: {
+        disabled?: boolean;
+        selected?: boolean;
+    }) => TableRowAttributes) | undefined;
+    onGroupedRow?: ((record?: Record<string, unknown>, index?: number) => TableRowAttributes) | undefined;
+    prefixCls: string;
+    renderCell?: ((props: {
+        column: NormalizedTableColumn<Record<string, unknown>>;
+        record: Record<string, unknown>;
+        rowIndex: number;
+        text: unknown;
+    }) => VNodeChild) | undefined;
+    renderExpandedRow?: ((props: {
+        expanded: boolean;
+        index: number;
+        record: Record<string, unknown>;
+    }) => VNodeChild) | undefined;
+    renderGroupSection?: ((props: {
+        group: Record<string, unknown>[];
+        groupKey: TableRowKey;
+    }) => VNodeChild) | undefined;
+    rowExpandable?: ((record?: Record<string, unknown>) => boolean) | undefined;
+    rows: FlatTableRecord<Record<string, unknown>>[];
+    rowSelection?: false | TableRowSelection<Record<string, unknown>> | undefined;
+    rowSpanHover?: boolean | undefined;
+    selectedKeys: ReadonlySet<TableRowKey>;
+    virtualBottom?: number | undefined;
+    virtualTop?: number | undefined;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    expand: (row: FlatTableRecord<Record<string, unknown>>, event: MouseEvent) => any;
+    select: (row: FlatTableRecord<Record<string, unknown>>, selected: boolean, event: Event) => any;
+    groupExpand: (groupKey: TableRowKey, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onExpand?: (row: FlatTableRecord<Record<string, unknown>>, event: MouseEvent) => any;
+    onSelect?: (row: FlatTableRecord<Record<string, unknown>>, selected: boolean, event: Event) => any;
+    onGroupExpand?: (groupKey: TableRowKey, event: MouseEvent) => any;
+}>, {
+    indentSize: number;
+    componentCell: Component | string | undefined;
+    componentRow: Component | string | undefined;
+    componentWrapper: Component | string | undefined;
+    virtualBottom: number | undefined;
+    virtualTop: number | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/table/TableCell.vue.d.ts

@@ -0,0 +1,37 @@
+import { Component, VNodeChild } from 'vue';
+import { NormalizedTableColumn } from './table-utils';
+import { TableDirection } from './types';
+interface Props {
+    column: NormalizedTableColumn<Record<string, unknown>>;
+    component?: Component | string | undefined;
+    direction: TableDirection;
+    expanded?: boolean | undefined;
+    expandNode?: VNodeChild | undefined;
+    fixedEdge?: boolean | undefined;
+    fixedOffset?: number | undefined;
+    fixedSide?: 'left' | 'right' | undefined;
+    hovered?: boolean | undefined;
+    indent?: number | undefined;
+    indentSize?: number | undefined;
+    prefixCls: string;
+    record: Record<string, unknown>;
+    rowIndex: number;
+    selected?: boolean | undefined;
+    selectionNode?: VNodeChild | undefined;
+    renderCell?: ((props: {
+        column: NormalizedTableColumn<Record<string, unknown>>;
+        record: Record<string, unknown>;
+        rowIndex: number;
+        text: unknown;
+    }) => VNodeChild) | undefined;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    component: Component | string | undefined;
+    indent: number | undefined;
+    hovered: boolean | undefined;
+    fixedEdge: boolean | undefined;
+    fixedOffset: number | undefined;
+    indentSize: number | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/table/TableColumn.d.ts

@@ -0,0 +1,81 @@
+import { PropType } from 'vue';
+import { TableColumn } from './types';
+export declare const TABLE_COLUMN_MARK: unique symbol;
+export declare const TableColumnComponent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    align: PropType<TableColumn["align"]>;
+    className: StringConstructor;
+    colSpan: NumberConstructor;
+    dataIndex: StringConstructor;
+    defaultFilteredValue: PropType<unknown[]>;
+    defaultSortOrder: PropType<TableColumn["defaultSortOrder"]>;
+    ellipsis: PropType<TableColumn["ellipsis"]>;
+    filterChildrenRecord: BooleanConstructor;
+    filterConfirmMode: PropType<TableColumn["filterConfirmMode"]>;
+    filterDropdown: null;
+    filterDropdownProps: ObjectConstructor;
+    filterDropdownVisible: BooleanConstructor;
+    filterIcon: null;
+    filterMultiple: BooleanConstructor;
+    filteredValue: PropType<unknown[]>;
+    filters: PropType<TableColumn["filters"]>;
+    fixed: PropType<TableColumn["fixed"]>;
+    onCell: PropType<TableColumn["onCell"]>;
+    onFilter: PropType<TableColumn["onFilter"]>;
+    onFilterDropdownVisibleChange: PropType<TableColumn["onFilterDropdownVisibleChange"]>;
+    onHeaderCell: PropType<TableColumn["onHeaderCell"]>;
+    render: PropType<TableColumn["render"]>;
+    renderFilterDropdown: PropType<TableColumn["renderFilterDropdown"]>;
+    renderFilterDropdownItem: PropType<TableColumn["renderFilterDropdownItem"]>;
+    resize: BooleanConstructor;
+    showSortTip: BooleanConstructor;
+    sortChildrenRecord: BooleanConstructor;
+    sorter: PropType<TableColumn["sorter"]>;
+    sortIcon: PropType<TableColumn["sortIcon"]>;
+    sortOrder: PropType<TableColumn["sortOrder"]>;
+    title: null;
+    useFullRender: BooleanConstructor;
+    width: (StringConstructor | NumberConstructor)[];
+}>, () => null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    align: PropType<TableColumn["align"]>;
+    className: StringConstructor;
+    colSpan: NumberConstructor;
+    dataIndex: StringConstructor;
+    defaultFilteredValue: PropType<unknown[]>;
+    defaultSortOrder: PropType<TableColumn["defaultSortOrder"]>;
+    ellipsis: PropType<TableColumn["ellipsis"]>;
+    filterChildrenRecord: BooleanConstructor;
+    filterConfirmMode: PropType<TableColumn["filterConfirmMode"]>;
+    filterDropdown: null;
+    filterDropdownProps: ObjectConstructor;
+    filterDropdownVisible: BooleanConstructor;
+    filterIcon: null;
+    filterMultiple: BooleanConstructor;
+    filteredValue: PropType<unknown[]>;
+    filters: PropType<TableColumn["filters"]>;
+    fixed: PropType<TableColumn["fixed"]>;
+    onCell: PropType<TableColumn["onCell"]>;
+    onFilter: PropType<TableColumn["onFilter"]>;
+    onFilterDropdownVisibleChange: PropType<TableColumn["onFilterDropdownVisibleChange"]>;
+    onHeaderCell: PropType<TableColumn["onHeaderCell"]>;
+    render: PropType<TableColumn["render"]>;
+    renderFilterDropdown: PropType<TableColumn["renderFilterDropdown"]>;
+    renderFilterDropdownItem: PropType<TableColumn["renderFilterDropdownItem"]>;
+    resize: BooleanConstructor;
+    showSortTip: BooleanConstructor;
+    sortChildrenRecord: BooleanConstructor;
+    sorter: PropType<TableColumn["sorter"]>;
+    sortIcon: PropType<TableColumn["sortIcon"]>;
+    sortOrder: PropType<TableColumn["sortOrder"]>;
+    title: null;
+    useFullRender: BooleanConstructor;
+    width: (StringConstructor | NumberConstructor)[];
+}>> & Readonly<{}>, {
+    resize: boolean;
+    filterChildrenRecord: boolean;
+    filterDropdownVisible: boolean;
+    filterMultiple: boolean;
+    showSortTip: boolean;
+    sortChildrenRecord: boolean;
+    useFullRender: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default TableColumnComponent;

package/dist/table/TableFilterMenu.vue.d.ts

@@ -0,0 +1,18 @@
+import { VNodeChild } from 'vue';
+import { TableFilter } from './types';
+type __VLS_Props = {
+    filters: TableFilter[];
+    level?: number;
+    multiple: boolean;
+    renderItem?: ((props?: Record<string, unknown>) => VNodeChild) | undefined;
+    selected: unknown[];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggle: (filter: TableFilter, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: (filter: TableFilter, event: MouseEvent) => any;
+}>, {
+    level: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/table/TableHeader.vue.d.ts

@@ -0,0 +1,46 @@
+import { Component, StyleValue, VNodeChild } from 'vue';
+import { NormalizedTableColumn, TableHeaderCell } from './table-utils';
+import { TableColumn, TableDirection, TableLocale, TableResizable, TableRowSelection, TableSortOrder, TableSticky } from './types';
+interface Props {
+    componentCell?: Component | string | undefined;
+    componentRow?: Component | string | undefined;
+    componentWrapper?: Component | string | undefined;
+    dataCount: number;
+    direction: TableDirection;
+    filterValues: ReadonlyMap<string | number, unknown[]>;
+    fixedOffsets: ReadonlyMap<string | number, {
+        side: 'left' | 'right';
+        value: number;
+        edge: boolean;
+    }>;
+    headerStyle?: StyleValue | undefined;
+    headerRows: TableHeaderCell<Record<string, unknown>>[][];
+    locale: TableLocale;
+    onHeaderRow?: ((columns?: TableColumn<Record<string, unknown>>[], index?: number) => Record<string, unknown>) | undefined;
+    prefixCls: string;
+    resizable?: boolean | TableResizable<Record<string, unknown>> | undefined;
+    rowSelection?: false | TableRowSelection<Record<string, unknown>> | undefined;
+    selectedCount: number;
+    sortOrders: ReadonlyMap<string | number, TableSortOrder>;
+    sticky?: boolean | TableSticky | undefined;
+    renderHeaderCell?: ((props: {
+        column: NormalizedTableColumn<Record<string, unknown>>;
+    }) => VNodeChild) | undefined;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: (column: NormalizedTableColumn<Record<string, unknown>>, event: Event) => any;
+    filter: (column: NormalizedTableColumn<Record<string, unknown>>, values: unknown[]) => any;
+    resize: (column: NormalizedTableColumn<Record<string, unknown>>, width: number, phase: "stop" | "start" | "move") => any;
+    selectAll: (selected: boolean, event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSort?: (column: NormalizedTableColumn<Record<string, unknown>>, event: Event) => any;
+    onFilter?: (column: NormalizedTableColumn<Record<string, unknown>>, values: unknown[]) => any;
+    onResize?: (column: NormalizedTableColumn<Record<string, unknown>>, width: number, phase: "stop" | "start" | "move") => any;
+    onSelectAll?: (selected: boolean, event: Event) => any;
+}>, {
+    componentCell: Component | string | undefined;
+    componentRow: Component | string | undefined;
+    componentWrapper: Component | string | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/table/TableNativeElement.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Keeps the native table element out of Vue's component-name resolution.
+ * A dynamic `is="table"` inside the Table SFC can otherwise resolve back to
+ * the current component because HTML tag names are case-insensitive.
+ */
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/table/TableNodeRenderer.d.ts

@@ -0,0 +1,13 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: {
+    name: string;
+    props: {
+        content: PropType<VNodeChild>;
+    };
+    setup(props: {
+        content?: VNodeChild;
+    }): () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+};
+export default _default;

package/dist/table/TableSpin.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    spinning: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/table/index.d.ts

@@ -0,0 +1,13 @@
+import { DefineComponent } from 'vue';
+import { TableColumn as TableColumnProps, TableExposed, TableProps } from './types';
+export declare const DEFAULT_KEY_COLUMN_SELECTION: "column-selection";
+export declare const DEFAULT_KEY_COLUMN_EXPAND: "column-expand";
+export type TableComponent = DefineComponent<TableProps, TableExposed> & {
+    Column: DefineComponent<TableColumnProps>;
+    DEFAULT_KEY_COLUMN_SELECTION: typeof DEFAULT_KEY_COLUMN_SELECTION;
+    DEFAULT_KEY_COLUMN_EXPAND: typeof DEFAULT_KEY_COLUMN_EXPAND;
+};
+export declare const TableColumn: DefineComponent<TableColumnProps>;
+export declare const Table: TableComponent;
+export default Table;
+export type { TableAlign, TableCellAttributes, TableChangeInfo, TableCheckRelation, TableColumn as TableColumnProps, TableColumnRender, TableColumnTitleProps, TableComponents, TableDirection, TableEmits, TableExposed, TableFilter, TableFilterConfirmMode, TableFixed, TableLocale, TablePaginationConfig, TableProps, TableRenderOptions, TableRenderReturnObject, TableResizable, TableRowAttributes, TableRowKey, TableRowSelection, TableRowSelectionRenderCellArgs, TableScroll, TableSize, TableSlots, TableSortOrder, TableSticky, TableVirtualized, TableVirtualizedItemSize, TableVirtualizedItemRow, TableVirtualizedListRef, TableVirtualizedOnScrollArgs, TableVirtualizedProps, } from './types';

package/dist/table/index.js

@@ -0,0 +1,2 @@
+import { i as e, n as t, r as n, t as r } from "../table-jZkHjf-W.js";
+export { r as DEFAULT_KEY_COLUMN_EXPAND, t as DEFAULT_KEY_COLUMN_SELECTION, n as Table, n as default, e as TableColumn };

package/dist/table/table-utils.d.ts

@@ -0,0 +1,43 @@
+import { TableColumn as TableColumnType, TableFixed, TableRowKey } from './types';
+export interface NormalizedTableColumn<RecordType extends Record<string, unknown>> extends TableColumnType<RecordType> {
+    key: TableRowKey;
+    children?: NormalizedTableColumn<RecordType>[] | undefined;
+    __width?: string | number | undefined;
+    __kind?: 'expand' | 'selection' | undefined;
+}
+export interface TableHeaderCell<RecordType extends Record<string, unknown>> {
+    column: NormalizedTableColumn<RecordType>;
+    colSpan: number;
+    rowSpan: number;
+}
+export interface FlatTableRecord<RecordType> {
+    index: number;
+    key: TableRowKey;
+    level: number;
+    parentKey?: TableRowKey | undefined;
+    record: RecordType;
+    group?: RecordType[] | undefined;
+    groupKey?: TableRowKey | undefined;
+    sectionRow?: boolean | undefined;
+}
+export declare function toCssSize(value?: string | number): string | undefined;
+export declare function getByPath(record: Record<string, unknown>, path?: string): unknown;
+export declare function getRecordKey<RecordType extends Record<string, unknown>>(record: RecordType, rowKey?: string | number | ((record?: RecordType) => TableRowKey), fallback?: number): TableRowKey;
+export declare function normalizeColumnVNodes<RecordType extends Record<string, unknown>>(value: unknown): NormalizedTableColumn<RecordType>[];
+export declare function normalizeColumn<RecordType extends Record<string, unknown>>(source: TableColumnType<RecordType>, index: number, level?: number): NormalizedTableColumn<RecordType>;
+export declare function normalizeColumns<RecordType extends Record<string, unknown>>(columns?: TableColumnType<RecordType>[]): NormalizedTableColumn<RecordType>[];
+export declare function flattenColumns<RecordType extends Record<string, unknown>>(columns: NormalizedTableColumn<RecordType>[]): NormalizedTableColumn<RecordType>[];
+export declare function buildHeaderRows<RecordType extends Record<string, unknown>>(columns: NormalizedTableColumn<RecordType>[]): TableHeaderCell<RecordType>[][];
+export declare function flattenRecords<RecordType extends Record<string, unknown>>(records: RecordType[], options: {
+    childrenRecordName: string;
+    expandedKeys: ReadonlySet<TableRowKey>;
+    rowKey: string | number | ((record?: RecordType) => TableRowKey);
+}, level?: number, parentKey?: TableRowKey, indexOffset?: {
+    value: number;
+}): FlatTableRecord<RecordType>[];
+export declare function fixedOffsets<RecordType extends Record<string, unknown>>(columns: NormalizedTableColumn<RecordType>[]): Map<TableRowKey, {
+    side: 'left' | 'right';
+    value: number;
+    edge: boolean;
+}>;
+export declare function normalizeFixed(value?: TableFixed): 'left' | 'right' | undefined;