bj-web-components 0.2.15 → 0.2.17

package/dist/web/Table/Column.d.ts

@@ -0,0 +1,3 @@
+import { ColumnProps } from './types';
+declare function Column<RecordType>(_: ColumnProps<RecordType>): null;
+export default Column;

package/dist/web/Table/ColumnGroup.d.ts

@@ -0,0 +1,3 @@
+import { ColumnGroupProps } from './types';
+declare function ColumnGroup<RecordType>(_: ColumnGroupProps<RecordType>): null;
+export default ColumnGroup;

package/dist/web/Table/index.d.ts

@@ -0,0 +1,4 @@
+export { BTable } from './BTable';
+export { default as Column } from './Column';
+export { default as ColumnGroup } from './ColumnGroup';
+export type { Breakpoint, CellType, ColumnFilterItem, ColumnGroupProps, ColumnGroupType, ColumnProps, ColumnsType, ColumnTitleProps, ColumnType, CompareFn, ExpandableConfig, FilterDropdownProps, FilterRequest, FilterSearchType, FilterValue, FixedType, GetRowKey, RenderedCell, SortOrder, SorterResult, TableAlign, TableComponents, TableDataIndex, TableKey, TableLocale, TablePaginationConfig, TableProps, TableRowSelection, TableSelectionType, TableSize, } from './types';

package/dist/web/Table/types.d.ts

@@ -0,0 +1,299 @@
+import { CSSProperties, HTMLAttributes, Key, ReactElement, ReactNode, Ref, TdHTMLAttributes } from 'react';
+import { PaginationProps } from '../Pagination';
+import { BDropdownProps } from '../Dropdown';
+export type TableKey = Exclude<Key, bigint>;
+export type TableDataIndex = string | number | readonly (string | number)[];
+export type TableSize = 'large' | 'middle' | 'small';
+export type TableSelectionType = 'checkbox' | 'radio';
+export type TableAlign = 'left' | 'center' | 'right';
+export type FixedType = 'left' | 'right' | boolean;
+export type TableLayout = 'auto' | 'fixed';
+export type SortOrder = 'ascend' | 'descend' | null;
+export type TableAction = 'paginate' | 'sort' | 'filter';
+export type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type FilterValue = Array<TableKey | boolean>;
+export type FilterKey = Array<string | number> | null;
+export type RowSelectMethod = 'all' | 'none' | 'invert' | 'single' | 'multiple';
+export interface RenderedCell<RecordType> {
+    children?: ReactNode;
+    props?: CellType<RecordType>;
+}
+export interface CellType<RecordType> {
+    key?: Key;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+    column?: ColumnsType<RecordType>[number];
+    colSpan?: number;
+    rowSpan?: number;
+}
+export interface ColumnFilterItem {
+    text: ReactNode;
+    /** Secondary text forwarded to the built-in BDropdown in double-line mode. */
+    description?: ReactNode;
+    value: TableKey | boolean;
+    children?: ColumnFilterItem[];
+}
+export interface ColumnTitleProps<RecordType> {
+    sortOrder?: SortOrder;
+    sortColumn?: ColumnType<RecordType>;
+    sortColumns?: Array<{
+        column: ColumnType<RecordType>;
+        order: SortOrder;
+    }>;
+    filters?: Record<string, FilterValue>;
+}
+export type ColumnTitle<RecordType> = ReactNode | ((props: ColumnTitleProps<RecordType>) => ReactNode);
+export type CompareFn<RecordType> = (first: RecordType, second: RecordType, sortOrder?: SortOrder) => number;
+export type FilterSearchType<RecordType = ColumnFilterItem> = boolean | ((input: string, item: RecordType) => boolean);
+export type FilterRequest = (input: string) => ColumnFilterItem[] | Promise<ColumnFilterItem[]>;
+export interface FilterDropdownProps {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: TableKey[]) => void;
+    selectedKeys: TableKey[];
+    confirm: (options?: {
+        closeDropdown?: boolean;
+    }) => void;
+    clearFilters?: (options?: {
+        confirm?: boolean;
+        closeDropdown?: boolean;
+    }) => void;
+    filters?: ColumnFilterItem[];
+    close: () => void;
+    visible: boolean;
+}
+export type GetComponentProps<DataType> = (data: DataType, index?: number) => HTMLAttributes<HTMLElement> | TdHTMLAttributes<HTMLTableCellElement>;
+export interface ColumnSharedType<RecordType> {
+    title?: ColumnTitle<RecordType>;
+    /** Hint badge rendered beside the column title. Accepts text, icons, or custom JSX. */
+    badge?: ReactNode;
+    key?: TableKey;
+    className?: string;
+    fixed?: FixedType;
+    width?: number | string;
+    align?: TableAlign;
+    ellipsis?: boolean | {
+        showTitle?: boolean;
+    };
+    responsive?: Breakpoint[];
+    onHeaderCell?: GetComponentProps<ColumnsType<RecordType>[number]>;
+}
+export interface ColumnType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    rowSpan?: number;
+    dataIndex?: TableDataIndex;
+    render?: (value: unknown, record: RecordType, index: number) => ReactNode | RenderedCell<RecordType>;
+    shouldCellUpdate?: (record: RecordType, previousRecord: RecordType) => boolean;
+    onCell?: GetComponentProps<RecordType>;
+    sorter?: boolean | CompareFn<RecordType> | {
+        compare?: CompareFn<RecordType>;
+        multiple?: number;
+    };
+    sortOrder?: SortOrder;
+    defaultSortOrder?: SortOrder;
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean | {
+        title?: ReactNode;
+    };
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    /** Props forwarded to BDropdown when rendering the built-in filter panel. Table-managed options, value, and callbacks take precedence. */
+    filterDropdownProps?: Partial<BDropdownProps>;
+    filterDropdown?: ReactNode | ((props: FilterDropdownProps) => ReactNode);
+    filterMultiple?: boolean;
+    filteredValue?: FilterValue | null;
+    defaultFilteredValue?: FilterValue | null;
+    filterIcon?: ReactNode | ((filtered: boolean) => ReactNode);
+    filterMode?: 'menu' | 'tree';
+    /** Show a search input. Pass a matcher to search custom option fields. */
+    filterSearch?: FilterSearchType;
+    /** Load filter options externally after the search input's 300ms debounce. */
+    filterRequest?: FilterRequest;
+    onFilter?: (value: TableKey | boolean, record: RecordType) => boolean;
+    filterDropdownOpen?: boolean;
+    onFilterDropdownOpenChange?: (open: boolean) => void;
+    filterResetToDefaultFilteredValue?: boolean;
+    /** @deprecated Use filterDropdownOpen. */
+    filterDropdownVisible?: boolean;
+    /** @deprecated Use onFilterDropdownOpenChange. */
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+}
+export interface ColumnGroupType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    children: ColumnsType<RecordType>;
+}
+export type ColumnsType<RecordType = unknown> = readonly (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export type GetRowKey<RecordType> = (record: RecordType, index?: number) => TableKey;
+export type RowClassName<RecordType> = (record: RecordType, index: number, indent: number) => string;
+export interface ExpandableConfig<RecordType> {
+    expandedRowKeys?: readonly TableKey[];
+    defaultExpandedRowKeys?: readonly TableKey[];
+    expandedRowRender?: (record: RecordType, index: number, indent: number, expanded: boolean) => ReactNode;
+    columnTitle?: ReactNode;
+    expandRowByClick?: boolean;
+    expandIcon?: (props: {
+        prefixCls: string;
+        expanded: boolean;
+        record: RecordType;
+        expandable: boolean;
+        onExpand: (record: RecordType, event: React.MouseEvent<HTMLElement>) => void;
+    }) => ReactNode;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedKeys: readonly TableKey[]) => void;
+    defaultExpandAllRows?: boolean;
+    indentSize?: number;
+    expandIconColumnIndex?: number;
+    showExpandColumn?: boolean;
+    expandedRowClassName?: RowClassName<RecordType>;
+    childrenColumnName?: string;
+    rowExpandable?: (record: RecordType) => boolean;
+    columnWidth?: number | string;
+    fixed?: FixedType;
+}
+export interface TableRowSelection<RecordType> {
+    preserveSelectedRowKeys?: boolean;
+    type?: TableSelectionType;
+    selectedRowKeys?: TableKey[];
+    defaultSelectedRowKeys?: TableKey[];
+    getCheckboxProps?: (record: RecordType) => {
+        disabled?: boolean;
+        name?: string;
+    };
+    columnTitle?: ReactNode;
+    columnWidth?: number | string;
+    fixed?: FixedType;
+    hideSelectAll?: boolean;
+    checkStrictly?: boolean;
+    selections?: boolean | Array<{
+        key: string;
+        text: ReactNode;
+        onSelect?: (keys: TableKey[]) => void;
+    }>;
+    renderCell?: (checked: boolean, record: RecordType, index: number, originNode: ReactNode) => ReactNode | RenderedCell<RecordType>;
+    onChange?: (selectedRowKeys: TableKey[], selectedRows: RecordType[], info?: {
+        type: RowSelectMethod;
+    }) => void;
+    onSelect?: (record: RecordType, selected: boolean, selectedRows: RecordType[], nativeEvent?: Event) => void;
+    onSelectAll?: (selected: boolean, selectedRows: RecordType[], changeRows?: RecordType[]) => void;
+    onSelectInvert?: (selectedRowKeys: TableKey[]) => void;
+    onSelectNone?: () => void;
+    onSelectMultiple?: (selected: boolean, selectedRows: RecordType[], changeRows: RecordType[]) => void;
+}
+export interface TablePaginationConfig extends PaginationProps {
+    position?: Array<'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'none'>;
+    /** Render the supplied data as the current server-side page without local slicing. */
+    serverPagination?: boolean;
+}
+export interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: ReactNode;
+    filterReset?: ReactNode;
+    filterEmptyText?: ReactNode;
+    filterCheckall?: ReactNode;
+    filterSearchPlaceholder?: string;
+    emptyText?: ReactNode | (() => ReactNode);
+    selectAll?: ReactNode;
+    selectNone?: ReactNode;
+    selectInvert?: ReactNode;
+    selectionAll?: ReactNode;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+export interface SorterResult<RecordType> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: TableKey | readonly TableKey[];
+    columnKey?: TableKey;
+}
+export interface TableCurrentDataSource<RecordType> {
+    currentDataSource: RecordType[];
+    action: TableAction;
+}
+export interface TableComponents<RecordType> {
+    table?: React.ElementType;
+    header?: {
+        wrapper?: React.ElementType;
+        row?: React.ElementType;
+        cell?: React.ElementType;
+    };
+    body?: {
+        wrapper?: React.ElementType;
+        row?: React.ElementType;
+        cell?: React.ElementType;
+    } | ((data: readonly RecordType[], info: {
+        scrollbarSize: number;
+        ref: Ref<{
+            scrollLeft: number;
+        }>;
+        onScroll: (info: {
+            currentTarget?: HTMLElement;
+            scrollLeft?: number;
+        }) => void;
+    }) => ReactNode);
+}
+export interface TableProps<RecordType extends object> {
+    columns?: ColumnsType<RecordType>;
+    children?: ReactNode;
+    dataSource?: readonly RecordType[];
+    rowKey?: keyof RecordType | string | GetRowKey<RecordType>;
+    rowSelection?: TableRowSelection<RecordType>;
+    pagination?: false | TablePaginationConfig;
+    loading?: boolean | {
+        spinning?: boolean;
+        tip?: ReactNode;
+        indicator?: ReactNode;
+    };
+    bordered?: boolean;
+    size?: TableSize;
+    showHeader?: boolean;
+    /** Empty-state description. Defaults to `t('暂无数据')`. */
+    emptyText?: ReactNode | (() => ReactNode);
+    /** Empty-state image URL or custom image node. */
+    emptyImage?: string | ReactNode;
+    /** Empty-state body height. Defaults to 454px. */
+    emptyHeight?: number | string;
+    /** Translation function used by built-in Table text. */
+    t?: (text: string) => string;
+    className?: string;
+    style?: CSSProperties;
+    id?: string;
+    rowClassName?: string | RowClassName<RecordType>;
+    tableLayout?: TableLayout;
+    scroll?: {
+        x?: number | true | string;
+        y?: number | string;
+        scrollToFirstRowOnChange?: boolean;
+    };
+    sticky?: boolean | {
+        offsetHeader?: number;
+        offsetSummary?: number;
+        offsetScroll?: number;
+        getContainer?: () => Window | HTMLElement;
+    };
+    direction?: 'ltr' | 'rtl';
+    title?: (data: readonly RecordType[]) => ReactNode;
+    footer?: (data: readonly RecordType[]) => ReactNode;
+    summary?: (data: readonly RecordType[]) => ReactNode;
+    components?: TableComponents<RecordType>;
+    onRow?: GetComponentProps<RecordType>;
+    onHeaderRow?: GetComponentProps<readonly ColumnType<RecordType>[]>;
+    expandable?: ExpandableConfig<RecordType>;
+    locale?: TableLocale;
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean | {
+        title?: ReactNode;
+    };
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    onChange?: (pagination: TablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult<RecordType> | SorterResult<RecordType>[], extra: TableCurrentDataSource<RecordType>) => void;
+    ref?: Ref<HTMLDivElement>;
+}
+export interface ColumnProps<RecordType> extends ColumnType<RecordType> {
+    children?: null;
+}
+export interface ColumnGroupProps<RecordType> extends Omit<ColumnGroupType<RecordType>, 'children'> {
+    children: ReactElement<ColumnProps<RecordType>> | Array<ReactElement<ColumnProps<RecordType>>>;
+}

package/dist/web/Table/utils/columns.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { ColumnGroupType, ColumnsType, ColumnType } from '../types';
+export interface HeaderCell<RecordType> {
+    column: ColumnGroupType<RecordType> | ColumnType<RecordType>;
+    colSpan: number;
+    rowSpan: number;
+    depth: number;
+}
+export declare function convertChildrenToColumns<RecordType>(children: ReactNode): ColumnsType<RecordType>;
+export declare function flattenColumns<RecordType>(columns: ColumnsType<RecordType>): ColumnType<RecordType>[];
+export declare function buildHeaderRows<RecordType>(columns: ColumnsType<RecordType>): HeaderCell<RecordType>[][];

package/dist/web/Table/utils/sortFilter.d.ts

@@ -0,0 +1,7 @@
+import { ColumnTitleProps, ColumnType, ColumnsType, FilterValue, SortOrder, SorterResult, TableKey } from '../types';
+export declare function getColumnKey<RecordType>(column: ColumnType<RecordType>, index: number): TableKey;
+export declare function renderColumnTitle<RecordType>(title: ColumnType<RecordType>['title'], props: ColumnTitleProps<RecordType>): import('react').ReactNode;
+export declare function getNextSortOrder(current: SortOrder, directions?: SortOrder[]): SortOrder;
+export declare function sortRecords<RecordType>(records: readonly RecordType[], columns: ColumnsType<RecordType>, orders: Map<TableKey, SortOrder>, childrenColumnName?: string): RecordType[];
+export declare function filterRecords<RecordType>(records: readonly RecordType[], columns: ColumnsType<RecordType>, filters: Map<TableKey, FilterValue | null>): RecordType[];
+export declare function getSorterResult<RecordType>(columns: ColumnsType<RecordType>, orders: Map<TableKey, SortOrder>): SorterResult<RecordType> | SorterResult<RecordType>[];

package/dist/web/Tabs/BTabs.d.ts

@@ -0,0 +1,8 @@
+import { default as TabPane } from './TabPane';
+import { BTabsProps } from './types';
+declare function BTabs({ activeKey, children, centered, className, defaultActiveKey, id, items, onChange, onTabClick, style, tabBarGutter, tabBarStyle, tabPosition, type, }: BTabsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace BTabs {
+    var TabPane: typeof import("./TabPane").default;
+}
+export { TabPane };
+export default BTabs;

package/dist/web/Tabs/TabPane.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+import { BTabsTabPaneProps } from './types';
+declare function TabPane(_: BTabsTabPaneProps): ReactElement | null;
+declare namespace TabPane {
+    var displayName: string;
+}
+export default TabPane;

package/dist/web/Tabs/index.d.ts

@@ -0,0 +1,3 @@
+export { default as BTabs } from './BTabs';
+export { default as TabPane } from './TabPane';
+export type { BTabsItem, BTabsPosition, BTabsProps, BTabsTabPaneProps, BTabsType } from './types';

package/dist/web/Tabs/types.d.ts

@@ -0,0 +1,32 @@
+import { CSSProperties, Key, ReactNode } from 'react';
+export type BTabsType = 'line' | 'card';
+export type BTabsPosition = 'top' | 'right' | 'bottom' | 'left';
+export interface BTabsItem {
+    key: string;
+    label: ReactNode;
+    children?: ReactNode;
+    disabled?: boolean;
+    forceRender?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface BTabsTabPaneProps extends Omit<BTabsItem, 'key' | 'label'> {
+    tab: ReactNode;
+    tabKey?: Key;
+}
+export interface BTabsProps {
+    activeKey?: string;
+    defaultActiveKey?: string;
+    items?: BTabsItem[];
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    id?: string;
+    tabPosition?: BTabsPosition;
+    type?: BTabsType;
+    centered?: boolean;
+    tabBarGutter?: number;
+    tabBarStyle?: CSSProperties;
+    onChange?: (activeKey: string) => void;
+    onTabClick?: (activeKey: string, event: React.MouseEvent<HTMLButtonElement>) => void;
+}

package/dist/web/Tooltip/ConfirmTooltip.d.ts

@@ -0,0 +1,2 @@
+import { ConfirmTooltipProps } from './types';
+export default function ConfirmTooltip({ placement, title, okText, cancelText, onOk, onCancel, className, style, }: ConfirmTooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/web/Tooltip/ContentTooltip.d.ts

@@ -0,0 +1,2 @@
+import { ContentTooltipProps } from './types';
+export default function BTooltip({ placement, content, variant, className, style, getPopupContainer, getAnchorElement, color, fontColor, }: ContentTooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/web/Tooltip/ProgressTooltip.d.ts

@@ -0,0 +1,2 @@
+import { ProgressTooltipProps } from './types';
+export default function ProgressTooltip({ placement, title, progress, className, style, }: ProgressTooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/web/Tooltip/TooltipWrapper.d.ts

@@ -0,0 +1,3 @@
+import { TooltipWrapperProps } from './types';
+declare const TooltipWrapper: import('react').ForwardRefExoticComponent<TooltipWrapperProps & import('react').RefAttributes<HTMLDivElement>>;
+export default TooltipWrapper;

package/dist/web/Tooltip/index.d.ts

@@ -0,0 +1,6 @@
+export { default as ConfirmTooltip } from './ConfirmTooltip';
+export { default as ProgressTooltip } from './ProgressTooltip';
+export { default as BTooltip } from './ContentTooltip';
+export { default as ContentTooltip } from './ContentTooltip';
+export { default as TooltipWrapper } from './TooltipWrapper';
+export type { TooltipPlacement, TooltipVariant, ConfirmTooltipProps, ProgressTooltipProps, ContentTooltipProps, ContentTooltipProps as BTooltipProps, TooltipWrapperProps, } from './types';

package/dist/web/Tooltip/types.d.ts

@@ -0,0 +1,36 @@
+import { CSSProperties, ReactNode } from 'react';
+export type TooltipPlacement = 'auto' | 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom' | 'right' | 'rightTop' | 'rightBottom';
+export type TooltipVariant = 'default' | 'light' | 'bordered' | 'tinted';
+export interface BaseTooltipProps {
+    placement?: TooltipPlacement;
+    className?: string;
+    style?: CSSProperties;
+    /** 自定义弹层挂载容器，默认 document.body */
+    getPopupContainer?: () => HTMLElement;
+    /** Optional element used as the positioning anchor when rendered through a portal. */
+    getAnchorElement?: () => HTMLElement | null;
+}
+export interface ConfirmTooltipProps extends BaseTooltipProps {
+    title?: string;
+    okText?: string;
+    cancelText?: string;
+    onOk?: () => void;
+    onCancel?: () => void;
+}
+export interface ProgressTooltipProps extends BaseTooltipProps {
+    title?: string;
+    progress?: number;
+}
+export interface ContentTooltipProps extends BaseTooltipProps {
+    content?: ReactNode;
+    variant?: TooltipVariant;
+    /** Tooltip background color, including the arrow. */
+    color?: string;
+    /** Tooltip content text color. */
+    fontColor?: string;
+}
+export interface TooltipWrapperProps {
+    children: React.ReactNode;
+    style?: CSSProperties;
+    className?: string;
+}

package/dist/web/Tooltip/useAutoPlacement.d.ts

@@ -0,0 +1,7 @@
+import { TooltipPlacement } from './types';
+/**
+ * 当 placement='auto' 时，顺时针探测视口空间，自动选出第一个放得下的方向。
+ * 返回 [resolvedPlacement, popupRef]，将 popupRef 绑到弹窗根节点即可。
+ * popupRef 是 callback ref，支持 portal 场景下弹窗异步挂载后重新触发计算。
+ */
+export declare function useAutoPlacement(placement: TooltipPlacement): [Exclude<TooltipPlacement, 'auto'>, (el: HTMLDivElement | null) => void];

package/dist/web/index.d.ts

@@ -0,0 +1,18 @@
+export * from './Icon';
+export * from './Tooltip';
+export * from './SkuInputCard';
+export * from './Input';
+export * from './BasicInput';
+export * from './Tabs';
+export * from './EmptyInputBox';
+export * from './Modal';
+export * from './ProductField';
+export * from './CategoryDropdown';
+export * from './Pagination';
+export * from './FileCard';
+export * from './Switch';
+export * from './InputNumber';
+export * from './Table';
+export * from './CheckBox';
+export * from './OverlayScrollbar';
+export * from './Dropdown';