@hanwenbo/x-taro-ui 0.0.1

package/lib/components/table/types.d.ts

@@ -0,0 +1,272 @@
+import type { CSSProperties, Key, ReactNode } from 'react';
+import type { SizeVariant } from '../../theme/types';
+export declare type TableRecord = Record<string, any>;
+export declare type TableSize = SizeVariant;
+export declare type TableAlign = 'left' | 'center' | 'right';
+export declare type TableSortOrder = 'ascend' | 'descend' | null;
+export declare type SortOrder = TableSortOrder;
+export declare type TableAction = 'paginate' | 'sort' | 'filter';
+export declare type TableFilterValue = Key[] | null;
+export declare type FilterValue = TableFilterValue;
+export declare type TableDataIndex = string | number | Array<string | number>;
+export declare type TableFixed = boolean | 'left' | 'right' | 'start' | 'end';
+export declare type TableSemanticDOM = 'root' | 'container' | 'table' | 'header' | 'body' | 'row' | 'cell' | 'title' | 'footer' | 'pagination' | 'empty';
+export declare type TableClassNames = Partial<Record<TableSemanticDOM, string>>;
+export declare type TableStyles = Partial<Record<TableSemanticDOM, CSSProperties>>;
+export interface TableColumnFilterItem {
+    text: ReactNode;
+    value: Key;
+    children?: TableColumnFilterItem[];
+}
+export interface TableColumnSorterObject<RecordType extends TableRecord = TableRecord> {
+    compare?: (a: RecordType, b: RecordType) => number;
+    multiple?: number;
+}
+export interface TableSorterResult<RecordType extends TableRecord = TableRecord> {
+    column?: TableColumn<RecordType>;
+    columnKey?: Key;
+    field?: TableDataIndex;
+    order?: Exclude<TableSortOrder, null>;
+}
+export declare type TableSorterValue<RecordType extends TableRecord = TableRecord> = TableSorterResult<RecordType> | TableSorterResult<RecordType>[];
+export interface TableColumnTitleProps<RecordType extends TableRecord = TableRecord> {
+    sortOrder?: TableSortOrder;
+    sortColumn?: TableColumn<RecordType>;
+    sortColumns?: TableSorterResult<RecordType>[];
+    filters?: Record<string, TableFilterValue>;
+}
+export interface TableFilterDropdownProps<RecordType extends TableRecord = TableRecord> {
+    clearFilters: () => void;
+    close: () => void;
+    column: TableColumn<RecordType>;
+    confirm: () => void;
+    filters?: TableColumnFilterItem[];
+    selectedKeys: Key[];
+    setSelectedKeys: (keys: Key[]) => void;
+    visible: boolean;
+}
+export interface TableColumn<RecordType extends TableRecord = TableRecord> {
+    key?: Key;
+    title?: ReactNode | ((props: TableColumnTitleProps<RecordType>) => ReactNode);
+    dataIndex?: TableDataIndex;
+    width?: number | string;
+    minWidth?: number | string;
+    align?: TableAlign;
+    fixed?: TableFixed;
+    ellipsis?: boolean | {
+        showTitle?: boolean;
+    };
+    responsive?: Array<'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl'>;
+    hidden?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    children?: TableColumn<RecordType>[];
+    sorter?: boolean | ((a: RecordType, b: RecordType) => number) | TableColumnSorterObject<RecordType>;
+    sortOrder?: TableSortOrder;
+    defaultSortOrder?: Exclude<TableSortOrder, null>;
+    sortDirections?: Array<Exclude<TableSortOrder, null>>;
+    filters?: TableColumnFilterItem[];
+    filteredValue?: TableFilterValue;
+    defaultFilteredValue?: Key[];
+    filterMultiple?: boolean;
+    filterDropdown?: ReactNode | ((props: TableFilterDropdownProps<RecordType>) => ReactNode);
+    onFilter?: (value: Key, record: RecordType) => boolean;
+    render?: (value: any, record: RecordType, index: number) => ReactNode;
+    onCell?: (record: RecordType, index: number) => Record<string, unknown>;
+    onHeaderCell?: (column: TableColumn<RecordType>) => Record<string, unknown>;
+    shouldCellUpdate?: (record: RecordType, previousRecord: RecordType) => boolean;
+}
+export declare type TableColumnType<RecordType extends TableRecord = TableRecord> = TableColumn<RecordType>;
+export declare type TableColumnConfig<RecordType extends TableRecord = TableRecord> = TableColumn<RecordType>;
+export declare type TableColumnsType<RecordType extends TableRecord = TableRecord> = Array<TableColumn<RecordType>>;
+export interface TableColumnProps<RecordType extends TableRecord = TableRecord> extends Omit<TableColumn<RecordType>, 'children'> {
+    children?: null;
+}
+export interface TableColumnGroupProps<RecordType extends TableRecord = TableRecord> extends Omit<TableColumn<RecordType>, 'children'> {
+    children?: ReactNode;
+}
+export interface TablePaginationConfig {
+    current?: number;
+    defaultCurrent?: number;
+    defaultPageSize?: number;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    size?: SizeVariant;
+    placement?: Array<'topStart' | 'topCenter' | 'topEnd' | 'bottomStart' | 'bottomCenter' | 'bottomEnd' | 'none'>;
+    position?: Array<'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'none'>;
+    showQuickJumper?: boolean;
+    showSizeChanger?: boolean;
+    showTotal?: (total: number, range: [number, number]) => ReactNode;
+    total?: number;
+    onChange?: (page: number, pageSize: number) => void;
+}
+export interface TableSelectionItem {
+    key?: Key;
+    text: ReactNode;
+    onSelect?: (changeableRowKeys: Key[]) => void;
+}
+export interface TableRowSelection<RecordType extends TableRecord = TableRecord> {
+    type?: 'checkbox' | 'radio';
+    align?: TableAlign;
+    columnTitle?: ReactNode | ((originalNode: ReactNode) => ReactNode);
+    columnWidth?: number | string;
+    selectedRowKeys?: Key[];
+    defaultSelectedRowKeys?: Key[];
+    preserveSelectedRowKeys?: boolean;
+    fixed?: boolean;
+    hideSelectAll?: boolean;
+    selections?: boolean | TableSelectionItem[];
+    getCheckboxProps?: (record: RecordType) => {
+        disabled?: boolean;
+    };
+    renderCell?: (checked: boolean, record: RecordType, index: number, originNode: ReactNode) => ReactNode;
+    onChange?: (selectedRowKeys: Key[], selectedRows: RecordType[], info: {
+        type: 'all' | 'single' | 'none' | 'invert';
+    }) => void;
+    onSelect?: (record: RecordType, selected: boolean, selectedRows: RecordType[]) => void;
+    onSelectAll?: (selected: boolean, selectedRows: RecordType[], changeRows: RecordType[]) => void;
+    onSelectInvert?: (selectedRowKeys: Key[]) => void;
+    onSelectNone?: () => void;
+}
+export interface TableExpandableConfig<RecordType extends TableRecord = TableRecord> {
+    childrenColumnName?: string;
+    columnTitle?: ReactNode;
+    columnWidth?: number | string;
+    defaultExpandAllRows?: boolean;
+    defaultExpandedRowKeys?: Key[];
+    expandedRowKeys?: Key[];
+    expandedRowRender?: (record: RecordType, index: number, indent: number, expanded: boolean) => ReactNode;
+    expandIcon?: (props: {
+        expanded: boolean;
+        expandable: boolean;
+        onExpand: (record: RecordType, event?: unknown) => void;
+        record: RecordType;
+    }) => ReactNode;
+    expandedRowClassName?: string | ((record: RecordType, index: number, indent: number) => string);
+    expandRowByClick?: boolean;
+    fixed?: boolean | 'left' | 'right';
+    indentSize?: number;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedRowKeys: Key[]) => void;
+    rowExpandable?: (record: RecordType) => boolean;
+    showExpandColumn?: boolean;
+}
+export interface TableLocale {
+    emptyText?: ReactNode;
+    loadingText?: ReactNode;
+    expand?: ReactNode;
+    collapse?: ReactNode;
+    filterConfirm?: ReactNode;
+    filterReset?: ReactNode;
+    filterTitle?: ReactNode;
+    selectAll?: ReactNode;
+    selectInvert?: ReactNode;
+    selectNone?: ReactNode;
+    sortTitle?: ReactNode;
+    cancelSort?: ReactNode;
+    triggerAsc?: ReactNode;
+    triggerDesc?: ReactNode;
+}
+export declare type TableLoadingConfig = boolean | {
+    delay?: number;
+    indicator?: ReactNode;
+    size?: 'small' | 'default' | 'large';
+    spinning?: boolean;
+    tip?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    wrapperClassName?: string;
+};
+export interface TableScrollConfig {
+    scrollToFirstRowOnChange?: boolean;
+    x?: number | string | true | 'max-content';
+    y?: number | string;
+}
+export interface TableChangeExtra<RecordType extends TableRecord = TableRecord> {
+    action: TableAction;
+    currentDataSource: RecordType[];
+}
+export interface TableRef {
+    nativeElement: unknown;
+    scrollTo: (config: {
+        index?: number;
+        key?: Key;
+        offset?: number;
+        top?: number;
+    }) => void;
+}
+export interface TableComponents {
+    table?: React.ElementType;
+    header?: {
+        wrapper?: React.ElementType;
+        row?: React.ElementType;
+        cell?: React.ElementType;
+    };
+    body?: {
+        wrapper?: React.ElementType;
+        row?: React.ElementType;
+        cell?: React.ElementType;
+    };
+}
+export interface TableProps<RecordType extends TableRecord = TableRecord> {
+    columns?: TableColumn<RecordType>[];
+    dataSource?: RecordType[];
+    children?: ReactNode;
+    rowKey?: keyof RecordType | string | ((record: RecordType, index: number) => Key);
+    bordered?: boolean;
+    classNames?: TableClassNames | ((info: {
+        props: TableProps<RecordType>;
+    }) => TableClassNames);
+    styles?: TableStyles | ((info: {
+        props: TableProps<RecordType>;
+    }) => TableStyles);
+    components?: TableComponents;
+    loading?: TableLoadingConfig;
+    locale?: TableLocale;
+    size?: SizeVariant;
+    showHeader?: boolean;
+    title?: ReactNode | ((currentPageData: RecordType[]) => ReactNode);
+    footer?: ReactNode | ((currentPageData: RecordType[]) => ReactNode);
+    summary?: ReactNode | ((currentPageData: RecordType[]) => ReactNode);
+    onChange?: (pagination: TablePaginationConfig, filters: Record<string, TableFilterValue>, sorter: TableSorterResult<RecordType> | TableSorterResult<RecordType>[], extra: TableChangeExtra<RecordType>) => void;
+    onRow?: (record: RecordType, index: number) => Record<string, unknown>;
+    onHeaderRow?: (columns: TableColumn<RecordType>[], index: number) => Record<string, unknown>;
+    rowClassName?: string | ((record: RecordType, index: number) => string);
+    rowHoverable?: boolean;
+    rowSelection?: TableRowSelection<RecordType>;
+    expandable?: TableExpandableConfig<RecordType>;
+    pagination?: false | TablePaginationConfig;
+    paginationVariant?: 'section' | 'plain';
+    scroll?: TableScrollConfig;
+    sticky?: boolean | {
+        offsetHeader?: number;
+        offsetScroll?: number;
+        getContainer?: () => unknown;
+    };
+    virtual?: boolean;
+    tableLayout?: 'auto' | 'fixed';
+    showSorterTooltip?: boolean | Record<string, unknown>;
+    sortDirections?: Array<Exclude<TableSortOrder, null>>;
+    onScroll?: (event: unknown) => void;
+    getPopupContainer?: (triggerNode?: unknown) => unknown;
+    className?: string;
+    style?: CSSProperties;
+    testID?: string;
+    /** @deprecated Use rowSelection. */
+    selectable?: boolean;
+    /** @deprecated Use rowSelection.selectedRowKeys. */
+    selectedRowKeys?: Key[];
+    /** @deprecated Use rowSelection.defaultSelectedRowKeys. */
+    defaultSelectedRowKeys?: Key[];
+    /** @deprecated Use rowSelection.onChange. */
+    onSelectionChange?: (keys: Key[], rows: RecordType[]) => void;
+    /** Existing x-taro-ui visual extension. */
+    striped?: boolean;
+    /** @deprecated Use expandable.expandedRowRender. */
+    expandedRowRender?: (record: RecordType, index: number) => ReactNode;
+    /** @deprecated Use expandable.defaultExpandedRowKeys. */
+    defaultExpandedRowKeys?: Key[];
+    /** @deprecated Use locale.emptyText. */
+    emptyText?: ReactNode;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/components/table/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/table/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/components/tabs/index.d.ts

@@ -0,0 +1,3 @@
+export { Tabs, TabItem, TabPane } from './tabs';
+export type { TabsProps, TabItem as TabItemData, TabItemProps, TabPaneProps, TabsRef } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/tabs/index.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/tabs/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TabItem: () => import_tabs.TabItem,
+  TabPane: () => import_tabs.TabPane,
+  Tabs: () => import_tabs.Tabs
+});
+module.exports = __toCommonJS(index_exports);
+var import_tabs = require("./tabs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TabItem,
+  TabPane,
+  Tabs
+});

package/lib/components/tabs/tabs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tabs Component
+ *
+ * Keeps Taro-specific vertical/card extensions while matching x-mobile-ui's
+ * defaults, selection semantics, slots and scroll contracts.
+ */
+import React from 'react';
+import type { TabItemProps, TabPaneProps, TabsProps, TabsRef } from './types';
+export declare const TabItem: React.FC<TabItemProps>;
+export declare const TabPane: React.FC<TabPaneProps>;
+export declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<TabsRef>> & {
+    Tab: typeof TabItem;
+    TabPane: typeof TabPane;
+};
+export default Tabs;
+//# sourceMappingURL=tabs.d.ts.map