amis-rev-ui 6.13.0

package/lib/components/menu/MenuContext.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @file Menu
+ * @description 导航菜单上下文
+ * @author fex
+ */
+import type { SubMenuProps } from './SubMenu';
+import type { NavigationItem } from './';
+export interface MenuContextProps {
+    /**
+     * 主题色
+     *
+     * @type {('light' | 'dark')}
+     * @memberof MenuContextProps
+     */
+    themeColor: 'light' | 'dark';
+    /**
+     * 导航模式
+     *
+     * @type {(true | false)}
+     * @memberof MenuContextProps
+     */
+    stacked?: true | false;
+    /**
+     * 布局
+     *
+     * @type {('inline' | 'float' | 'panel')}
+     * @memberof MenuContextProps
+     */
+    mode?: 'inline' | 'float' | 'panel';
+    /**
+     * mode不为horizontal时
+     *
+     * @type {boolean}
+     * @memberof MenuContextProps
+     */
+    collapsed?: boolean;
+    /**
+     * 布局方向
+     *
+     * @type {('ltr' | 'rtl')}
+     * @memberof MenuContextProps
+     */
+    direction?: 'ltr' | 'rtl';
+    /**
+     * 统一路由前缀
+     *
+     * @type {string}
+     * @memberof MenuContextProps
+     */
+    prefix?: string;
+    /**
+     * 垂直导航水平缩进值
+     */
+    inlineIndent?: number;
+    /**
+     * 手风琴模式
+     */
+    accordion?: boolean;
+    /**
+     * 是否可拖拽排序
+     */
+    draggable?: boolean;
+    /**
+     * 触发访问带有子菜单的父级路由
+     */
+    onSubmenuClick?: (SubmenuInfo: {
+        key: string;
+        domEvent: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+        props: SubMenuProps;
+    }) => void;
+    /**
+     * 面板菜单中的菜单项点击事件
+     */
+    onPanelMenuClick?: (PanelItemMenuInfo: {
+        key: string;
+        domEvent: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+        keyPath: string[];
+        props: NavigationItem;
+    }) => void;
+    onDragStart?: (link: any) => (event: React.DragEvent<HTMLAnchorElement>) => void;
+}
+export declare const MenuContext: import("react").Context<MenuContextProps>;

package/lib/components/schema-editor/Array.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { SchemaEditorItemCommon } from './Common';
+export declare class SchemaEditorItemArray extends SchemaEditorItemCommon {
+    state: {
+        collapsed: boolean;
+    };
+    toggleCollapsed(): void;
+    handleItemsChange(items: any): void;
+    renderItems(): React.JSX.Element;
+    render(): React.JSX.Element;
+}

package/lib/components/schema-editor/Common.d.ts

@@ -0,0 +1,61 @@
+import React from 'react';
+import { LocaleProps, ThemeProps, JSONSchema } from 'amis-rev-core';
+import { UseFormReturn } from 'react-hook-form';
+export declare const schemaEditorItemPlaceholder: {
+    key: string;
+    title: string;
+    description: string;
+    default: string;
+    empty: string;
+};
+export type SchemaEditorItemPlaceholder = Partial<typeof schemaEditorItemPlaceholder>;
+export interface SchemaEditorItemCommonProps extends LocaleProps, ThemeProps {
+    label?: string;
+    value?: JSONSchema;
+    dataName?: string;
+    onChange: (value: JSONSchema) => void;
+    types: Array<{
+        label: string;
+        value: string;
+        [propName: string]: any;
+    }>;
+    onTypeChange?: (type: string, value: JSONSchema, origin?: JSONSchema) => JSONSchema | void;
+    disabled?: boolean;
+    required?: boolean;
+    onRequiredChange?: (value: boolean) => void;
+    typeMutable?: boolean;
+    showInfo?: boolean;
+    addButtonText?: string;
+    renderExtraProps?: (value: JSONSchema, onChange: (value: JSONSchema) => void) => JSX.Element;
+    renderModalProps?: (value: JSONSchema, onChange: (value: JSONSchema) => void) => JSX.Element;
+    prefix?: JSX.Element;
+    affix?: JSX.Element;
+    enableAdvancedSetting?: boolean;
+    /** 各属性输入控件的placeholder */
+    placeholder?: SchemaEditorItemPlaceholder;
+    popOverContainer?: any;
+    mobileUI?: boolean;
+    mini?: boolean;
+    formMode?: boolean;
+    formRef?: any;
+    onFormConfirm?: (value: any) => void | Promise<any>;
+    expandMembers?: boolean;
+    formPrefixRender?: (methods: UseFormReturn & {
+        onSubmit: (value: any) => void;
+    }) => JSX.Element | null;
+    formAffixRender?: (methods: UseFormReturn & {
+        onSubmit: (value: any) => void;
+    }) => JSX.Element | null;
+}
+export declare class SchemaEditorItemCommon<P extends SchemaEditorItemCommonProps = SchemaEditorItemCommonProps, S = any> extends React.Component<P, S> {
+    handleTypeChange(type: any): void;
+    handlePropsChange(newValue: JSONSchema): Promise<void>;
+    handleBeforeSubmit(form: any): any;
+    renderCommon(): React.JSX.Element;
+    handleFormChange(values: any): void;
+    renderForm(props?: Partial<SchemaEditorItemCommonProps>): React.JSX.Element;
+    render(): React.JSX.Element;
+}
+export declare const ITEMMAP: {
+    [propsName: string]: typeof SchemaEditorItemCommon;
+};

package/lib/components/schema-editor/Item.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { LocaleProps, ThemeProps } from 'amis-rev-core';
+import { SchemaEditorItemCommonProps } from './Common';
+export interface SchemaEditorItemProps extends SchemaEditorItemCommonProps, LocaleProps, ThemeProps {
+}
+export declare class SchemaEditorItem extends React.Component<SchemaEditorItemProps> {
+    render(): React.JSX.Element;
+}

package/lib/components/schema-editor/Object.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import { JSONSchema } from 'amis-rev-core';
+import { SchemaEditorItemCommon } from './Common';
+import type { SchemaEditorItemCommonProps } from './Common';
+import { UseFormReturn } from 'react-hook-form';
+export interface SchemaEditorItemObjectState {
+    members: Array<{
+        id: string;
+        key: string;
+        hasError?: boolean;
+        required?: boolean;
+        schema: JSONSchema;
+    }>;
+    collapsed: boolean;
+}
+export declare class SchemaEditorItemObject extends SchemaEditorItemCommon<SchemaEditorItemCommonProps, SchemaEditorItemObjectState> {
+    state: {
+        members: {
+            id: string;
+            key: string;
+            hasError?: boolean;
+            required?: boolean;
+            schema: JSONSchema;
+        }[];
+        collapsed: boolean;
+    };
+    lastValue: any;
+    componentDidUpdate(prevProps: SchemaEditorItemCommonProps): void;
+    propsToMembers(props: SchemaEditorItemCommonProps): {
+        id: string;
+        key: string;
+        hasError?: boolean;
+        required?: boolean;
+        schema: JSONSchema;
+    }[];
+    pipeOut(): void;
+    handleAdd(): void;
+    handleAddProppertyConfirm({ key, isRequired: required, ...value }: any): void;
+    handleEditProppertyConfirm(index: number, value: any): void;
+    handlePropKeyChange(index: number, key: string): void;
+    handlePropTitleChange(index: number, title: string): void;
+    handlePropRemove(index: number): void;
+    handlePropChange(index: number, { key, isRequired: required, ...item }: any): void;
+    handlePropRequiredChange(index: number, required: boolean): void;
+    toggleCollapsed(): void;
+    renderFormPrefix(methods: UseFormReturn & {
+        onSubmit: (value: any) => void;
+    }): React.JSX.Element;
+    rendererProps(): React.JSX.Element;
+    render(): React.JSX.Element;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * @file table/BodyCell
+ * @author fex
+ */
+import React from 'react';
+import { ThemeProps, ClassNamesFn } from 'amis-rev-core';
+import { ColumnProps } from './index';
+import type { TestIdBuilder } from 'amis-rev-core';
+export interface Props extends ThemeProps {
+    fixed?: string | boolean;
+    selfSticky?: boolean;
+    rowSpan?: number | any;
+    colSpan?: number | any;
+    key?: string | number;
+    className?: string;
+    children?: any;
+    tagName?: string;
+    style?: Object;
+    column?: ColumnProps;
+    wrapperComponent: any;
+    depth?: number;
+    col?: string;
+    index?: number;
+    classnames: ClassNamesFn;
+    testIdBuilder?: TestIdBuilder;
+}
+export default class BodyCell extends React.PureComponent<Props> {
+    static defaultProps: {
+        fixed: string;
+        selfSticky: boolean;
+        wrapperComponent: string;
+        rowSpan: null;
+        colSpan: null;
+    };
+    render(): React.JSX.Element;
+}

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

@@ -0,0 +1,24 @@
+import React from 'react';
+import { ColumnProps } from './index';
+export default function ColGroup({ columns, colWidths, isFixed, syncTableWidth, initTableWidth, selectable, expandable, draggable, rowSelectionColumnWidth, expandableColumnWidth, isRightExpandable, isLeftExpandable, showReal }: {
+    columns: Array<ColumnProps>;
+    colWidths: {
+        [key: number]: {
+            width: number;
+            realWidth: number;
+            minWidth: number;
+            originWidth: number;
+        };
+    };
+    isFixed: boolean;
+    syncTableWidth?: Function;
+    initTableWidth?: Function;
+    selectable: boolean;
+    expandable: boolean;
+    draggable: boolean;
+    rowSelectionColumnWidth: number;
+    expandableColumnWidth: number;
+    isRightExpandable?: boolean;
+    isLeftExpandable?: boolean;
+    showReal?: boolean;
+}): React.JSX.Element;

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

@@ -0,0 +1,45 @@
+/**
+ * @file table/Head
+ * @author fex
+ */
+import React from 'react';
+import { ThemeProps } from 'amis-rev-core';
+import { ColumnProps, ThProps, TdProps, RowSelectionOptionProps } from './index';
+import type { TestIdBuilder } from 'amis-rev-core';
+export interface Props extends ThemeProps {
+    draggable: boolean;
+    selectable: boolean;
+    rowSelectionFixed: boolean;
+    rowSelectionType?: string;
+    selections?: Array<RowSelectionOptionProps>;
+    columns: Array<ColumnProps>;
+    rowSelectionKeyField: string;
+    maxSelectedLength?: number;
+    isRightExpandable?: boolean;
+    isLeftExpandable?: boolean;
+    selectedRowKeys: Array<string | number>;
+    dataSource: Array<any>;
+    resizable?: boolean;
+    expandable: boolean;
+    expandableFixed?: string | boolean;
+    childrenColumnName: string;
+    orderBy?: string;
+    popOverContainer?: () => HTMLElement;
+    isExpandable: boolean;
+    onSort: Function;
+    onSelectAll: Function;
+    onFilter?: Function;
+    onResizeMouseDown: Function;
+    testIdBuilder?: TestIdBuilder;
+    selfSticky?: boolean;
+}
+export default class Head extends React.PureComponent<Props> {
+    domRef: React.RefObject<HTMLTableSectionElement>;
+    thColumns: Array<Array<ThProps>>;
+    tdColumns: Array<TdProps>;
+    prependColumns(columns: Array<any>): void;
+    updateFixedRow(): void;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    render(): React.JSX.Element;
+}

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ClassNamesFn } from 'amis-rev-core';
+export interface ItemActionsProps {
+    classnames: ClassNamesFn;
+    children?: React.ReactNode | Array<React.ReactNode>;
+    dom: HTMLTableRowElement;
+}
+export default class ItemActionsWrapper extends React.PureComponent<ItemActionsProps, {}> {
+    render(): React.JSX.Element | undefined;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * @file table/BodyRow
+ * @author fex
+ */
+import React from 'react';
+import { ThemeProps } from 'amis-rev-core';
+import { ColumnProps } from './index';
+import type { TestIdBuilder } from 'amis-rev-core';
+export interface Props extends ThemeProps {
+    data: any;
+    rowIndex: number;
+    columns: ColumnProps[];
+    expandable: boolean;
+    expandableFixed?: boolean;
+    indentSize: number;
+    lineHeight?: string;
+    keyField?: string;
+    draggable: boolean;
+    levels: string;
+    isExpandable: boolean;
+    isExpandableRow: boolean;
+    colCount: number;
+    isRightExpandable?: boolean;
+    isLeftExpandable?: boolean;
+    isChecked: boolean;
+    rowClassName?: Function;
+    onExpand?: Function;
+    onCollapse?: Function;
+    onMouseEnter: Function;
+    onMouseLeave: Function;
+    onClick: Function;
+    onDoubleClick: Function;
+    onChange: Function;
+    childrenColumnName: string;
+    selectable: boolean;
+    rowSelectionFixed?: boolean;
+    rowSelectionType?: 'radio' | 'checkbox';
+    rowClickIgControl?: boolean;
+    hasChildrenRow: boolean;
+    hasChildrenChecked: boolean;
+    expandedRowClassName: string;
+    expandedRowRender?: Function;
+    isExpanded: boolean;
+    testIdBuilder?: TestIdBuilder;
+    [propName: string]: any;
+}
+export interface LazyRowProps extends Props {
+}
+export interface LazyRowState {
+    visible: boolean;
+}
+export default class LazyRow extends React.PureComponent<LazyRowProps, LazyRowState> {
+    constructor(props: LazyRowProps);
+    handleVisibleChange(visible: boolean, entry?: any): void;
+    render(): React.JSX.Element;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * @file table/SummaryRow
+ * @author fex
+ */
+import React from 'react';
+import { ThemeProps } from 'amis-rev-core';
+import { SummaryProps } from './index';
+export interface RowProps extends ThemeProps {
+    dataSource: Array<any>;
+    colCount: number;
+    isRightExpandable?: boolean;
+    row?: Array<SummaryProps>;
+    onMouseEnter: Function;
+    onMouseLeave: Function;
+}
+export interface Props extends RowProps {
+    summary: Array<SummaryProps | Array<SummaryProps>>;
+}
+export declare class SummaryRow extends React.PureComponent<RowProps> {
+    domRef: React.RefObject<HTMLTableRowElement>;
+    updateFixedRow(): void;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    render(): React.JSX.Element;
+}
+export default class SummaryRows extends React.PureComponent<Props> {
+    render(): React.JSX.Element[];
+}

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

@@ -0,0 +1,25 @@
+import { ColumnProps, SummaryProps, ThProps, TdProps, SortProps } from './index';
+export declare function checkChildrenRow(data: any, childrenColumnName: string): any;
+export declare function getDataChildrenKeys(data: any, childrenColumnName: string, rowSelectionKeyField: string): string[];
+export declare function getAllSelectableRows(dataSource: Array<any>, rowSelectionKeyField: string, childrenColumnName: string, expandable: boolean, selectedRowKeys: Array<string | number>, maxSelectedLength: number | undefined): {
+    rows: any[];
+    rowKeys: (string | number)[];
+    restSelectedKeys: (string | number)[];
+};
+export declare function getRowsByKeys(dataSource: Array<any>, keys: Array<string | number>, keyField: string, childrenColumnName: string): {
+    selectedRows: any[];
+    unSelectedRows: any[];
+};
+export declare function getMaxLevelThRowSpan(columns: Array<ColumnProps>): number;
+export declare function getThRowSpan(column: ColumnProps): number;
+export declare function getThColSpan(column: ColumnProps): number;
+export declare function buildColumns(columns: Array<ColumnProps> | undefined, thColumns: Array<Array<any>>, tdColumns: Array<ColumnProps> | undefined, maxLevel: number, depth?: number, fixed?: boolean | string): void;
+export declare function getBuildColumns(columns: Array<any>): {
+    thColumns: ThProps[][];
+    tdColumns: TdProps[];
+};
+export declare function updateFixedRow(row: HTMLTableRowElement, columns: Array<ColumnProps | SummaryProps>, cx: Function): void;
+export declare function updateStickyRow(thead: HTMLCollection, rowIndex: number): void;
+export declare function hasFixedColumn(columns: Array<ColumnProps | SummaryProps>): any;
+export declare function levelsSplit(level: string): number[];
+export declare function getSortData(data: Array<any>, columns: Array<ColumnProps>, childrenColumnName: string, sort?: SortProps): Array<any>;

package/lib/components/virtual-list/AutoSizer.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+export type Size = {
+    height: number;
+    width: number;
+};
+export type AutoSizerProps = {
+    WrapperComponent?: React.ElementType;
+    minHeight?: number;
+    children: (props: Size) => React.ReactNode;
+    onResize?: (props: Size) => void;
+};
+export default class AutoSizer extends React.PureComponent<AutoSizerProps, Size> {
+    unSensor: Function;
+    constructor(props: AutoSizerProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    sizer(dom: HTMLElement): void;
+    render(): React.JSX.Element;
+}

package/lib/components/virtual-list/SizeAndPositionManager.d.ts

@@ -0,0 +1,70 @@
+import { ALIGNMENT } from './constants';
+export type ItemSizeGetter = (index: number) => number;
+export type ItemSize = number | number[] | ItemSizeGetter;
+export interface SizeAndPosition {
+    size: number;
+    offset: number;
+}
+export interface Options {
+    itemCount: number;
+    itemSizeGetter: ItemSizeGetter;
+    estimatedItemSize: number;
+}
+export default class SizeAndPositionManager {
+    private itemSizeGetter;
+    private itemCount;
+    private estimatedItemSize;
+    private lastMeasuredIndex;
+    private itemSizeAndPositionData;
+    constructor({ itemCount, itemSizeGetter, estimatedItemSize }: Options);
+    updateConfig({ itemCount, itemSizeGetter, estimatedItemSize }: Partial<Options>): void;
+    getLastMeasuredIndex(): number;
+    /**
+     * This method returns the size and position for the item at the specified index.
+     * It just-in-time calculates (or used cached values) for items leading up to the index.
+     */
+    getSizeAndPositionForIndex(index: number): SizeAndPosition;
+    getSizeAndPositionOfLastMeasuredItem(): SizeAndPosition;
+    /**
+     * Total size of all items being measured.
+     * This value will be completedly estimated initially.
+     * As items as measured the estimate will be updated.
+     */
+    getTotalSize(): number;
+    /**
+     * Determines a new offset that ensures a certain item is visible, given the alignment.
+     *
+     * @param align Desired alignment within container; one of "start" (default), "center", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @return Offset to use to ensure the specified item is visible
+     */
+    getUpdatedOffsetForIndex({ align, containerSize, currentOffset, targetIndex }: {
+        align: ALIGNMENT | undefined;
+        containerSize: number;
+        currentOffset: number;
+        targetIndex: number;
+    }): number;
+    getVisibleRange({ containerSize, offset, overscanCount }: {
+        containerSize: number;
+        offset: number;
+        overscanCount: number;
+    }): {
+        start?: number;
+        stop?: number;
+    };
+    /**
+     * Clear all cached values for items after the specified index.
+     * This method should be called for any item that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionForIndex() is called.
+     */
+    resetItem(index: number): void;
+    /**
+     * Searches for the item (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest item index will be returned.
+     * This allows partially visible items (with offsets just before/above the fold) to be visible.
+     */
+    findNearestItem(offset: number): number;
+    private binarySearch;
+    private exponentialSearch;
+}

package/lib/components/virtual-list/constants.d.ts

@@ -0,0 +1,34 @@
+export declare enum ALIGNMENT {
+    AUTO = "auto",
+    START = "start",
+    CENTER = "center",
+    END = "end"
+}
+export declare enum DIRECTION {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+export declare enum SCROLL_CHANGE_REASON {
+    OBSERVED = "observed",
+    REQUESTED = "requested"
+}
+export declare const scrollProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const sizeProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const positionProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const marginProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const oppositeMarginProp: {
+    vertical: string;
+    horizontal: string;
+};

package/lib/components/virtual-list/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 基于 https://github.com/clauderic/react-tiny-virtual-list 改造，主要是加了宽度自适应
+ */
+import * as React from 'react';
+import SizeAndPositionManager, { ItemSize } from './SizeAndPositionManager';
+import { ALIGNMENT, DIRECTION, SCROLL_CHANGE_REASON } from './constants';
+export { DIRECTION as ScrollDirection } from './constants';
+export type ItemPosition = 'absolute' | 'sticky';
+export interface ItemStyle {
+    position: ItemPosition;
+    top?: number;
+    left: number;
+    width: string | number;
+    height?: number;
+    marginTop?: number;
+    marginLeft?: number;
+    marginRight?: number;
+    marginBottom?: number;
+    zIndex?: number;
+}
+export interface ItemInfo {
+    index: number;
+    style: ItemStyle;
+}
+export interface RenderedRows {
+    startIndex: number;
+    stopIndex: number;
+}
+export interface Props {
+    className?: string;
+    estimatedItemSize?: number;
+    height: number | string;
+    itemCount: number;
+    itemSize: ItemSize;
+    overscanCount?: number;
+    scrollOffset?: number;
+    scrollToIndex?: number;
+    scrollToAlignment?: ALIGNMENT;
+    scrollDirection?: DIRECTION;
+    stickyIndices?: number[];
+    style?: React.CSSProperties;
+    width?: number | string;
+    WrapperComponent?: React.ElementType;
+    InnerComponent?: React.ElementType;
+    innerStyleFilter?: (styles: object) => object;
+    prefix?: React.ReactNode | null;
+    onItemsRendered?({ startIndex, stopIndex }: RenderedRows): void;
+    onScroll?(offset: number, event: UIEvent): void;
+    renderItem(itemInfo: ItemInfo): React.ReactNode;
+}
+export interface State {
+    offset: number;
+    scrollChangeReason: SCROLL_CHANGE_REASON;
+}
+export default class VirtualList extends React.PureComponent<Props, State> {
+    static defaultProps: {
+        overscanCount: number;
+        scrollDirection: DIRECTION;
+        width: string;
+    };
+    static propTypes: {
+        estimatedItemSize: any;
+        height: any;
+        itemCount: any;
+        itemSize: any;
+        onScroll: any;
+        onItemsRendered: any;
+        overscanCount: any;
+        renderItem: any;
+        scrollOffset: any;
+        scrollToIndex: any;
+        scrollToAlignment: any;
+        scrollDirection: any;
+        stickyIndices: any;
+        style: any;
+        width: any;
+    };
+    itemSizeGetter: (itemSize: Props["itemSize"]) => (index: any) => any;
+    sizeAndPositionManager: SizeAndPositionManager;
+    readonly state: State;
+    private rootNode;
+    private styleCache;
+    componentDidMount(): void;
+    updateRootWidth(): void;
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    componentWillUnmount(): void;
+    scrollTo(value: number): void;
+    getOffsetForIndex(index: number, scrollToAlignment?: ALIGNMENT | undefined, itemCount?: number): number;
+    recomputeSizes(startIndex?: number): void;
+    render(): React.JSX.Element;
+    private getRef;
+    private handleScroll;
+    private getNodeOffset;
+    private getEstimatedItemSize;
+    private getSize;
+    private getStyle;
+}
+export { default as AutoSizer } from './AutoSizer';

package/lib/components/withBadge.d.ts

@@ -0,0 +1,2 @@
+import { withBadge } from './Badge';
+export default withBadge;