react-virtualized#InfiniteLoader TypeScript Examples
The following examples show how to use
react-virtualized#InfiniteLoader.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
| Source File: TransactionInfiniteList.tsx From End-to-End-Web-Testing-with-Cypress with MIT License | 5 votes |
|
TransactionInfiniteList: React.FC<TransactionListProps> = ({
transactions,
loadNextPage,
pagination,
}) => {
const classes = useStyles();
const theme = useTheme();
const isXsBreakpoint = useMediaQuery(theme.breakpoints.down("xs"));
const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
const itemCount = pagination.hasNextPages ? transactions.length + 1 : transactions.length;
const loadMoreItems = () => {
return new Promise((resolve) => {
return resolve(pagination.hasNextPages && loadNextPage(pagination.page + 1));
});
};
const isRowLoaded = (params: Index) =>
!pagination.hasNextPages || params.index < transactions.length;
// @ts-ignore
function rowRenderer({ key, index, style }) {
const transaction = get(index, transactions);
if (index < transactions.length) {
return (
<div key={key} style={style}>
<TransactionItem transaction={transaction} />
<Divider variant={isMobile ? "fullWidth" : "inset"} />
</div>
);
}
}
return (
<InfiniteLoader
isRowLoaded={isRowLoaded}
loadMoreRows={loadMoreItems}
rowCount={itemCount}
threshold={2}
>
{({ onRowsRendered, registerChild }) => (
<div data-test="transaction-list" className={classes.transactionList}>
<List
rowCount={itemCount}
ref={registerChild}
onRowsRendered={onRowsRendered}
height={isXsBreakpoint ? theme.spacing(74) : theme.spacing(88)}
width={isXsBreakpoint ? theme.spacing(38) : theme.spacing(110)}
rowHeight={isXsBreakpoint ? theme.spacing(28) : theme.spacing(16)}
rowRenderer={rowRenderer}
/>
</div>
)}
</InfiniteLoader>
);
}
Example #2
| Source File: TableWrapper.tsx From console with GNU Affero General Public License v3.0 | 4 votes |
|
TableWrapper = ({
itemActions,
columns,
onSelect,
records,
isLoading,
loadingMessage = <Typography component="h3">Loading...</Typography>,
entityName,
selectedItems,
idField,
classes,
radioSelection = false,
customEmptyMessage = "",
customPaperHeight = "",
noBackground = false,
columnsSelector = false,
textSelectable = false,
columnsShown = [],
onColumnChange = (column: string, state: boolean) => {},
infiniteScrollConfig,
sortConfig,
autoScrollToBottom = false,
disabled = false,
onSelectAll,
rowStyle,
parentClassName = "",
}: TableWrapperProps) => {
const [columnSelectorOpen, setColumnSelectorOpen] = useState<boolean>(false);
const [anchorEl, setAnchorEl] = React.useState<any>(null);
const findView = itemActions
? itemActions.find((el) => el.type === "view")
: null;
const clickAction = (rowItem: any) => {
if (findView) {
const valueClick = findView.sendOnlyId ? rowItem[idField] : rowItem;
let disabled = false;
if (findView.disableButtonFunction) {
if (findView.disableButtonFunction(valueClick)) {
disabled = true;
}
}
if (findView.to && !disabled) {
history.push(`${findView.to}/${valueClick}`);
return;
}
if (findView.onClick && !disabled) {
findView.onClick(valueClick);
}
}
};
const openColumnsSelector = (event: { currentTarget: any }) => {
setColumnSelectorOpen(!columnSelectorOpen);
setAnchorEl(event.currentTarget);
};
const closeColumnSelector = () => {
setColumnSelectorOpen(false);
setAnchorEl(null);
};
const columnsSelection = (columns: IColumns[]) => {
return (
<Fragment>
<IconButton
aria-describedby={"columnsSelector"}
color="primary"
onClick={openColumnsSelector}
size="large"
>
<ViewColumnIcon fontSize="inherit" />
</IconButton>
<Popover
anchorEl={anchorEl}
id={"columnsSelector"}
open={columnSelectorOpen}
anchorOrigin={{
vertical: "bottom",
horizontal: "left",
}}
transformOrigin={{
vertical: "top",
horizontal: "left",
}}
onClose={closeColumnSelector}
>
<div className={classes.shownColumnsLabel}>Shown Columns</div>
<div className={classes.popoverContent}>
{columns.map((column: IColumns) => {
return (
<CheckboxWrapper
key={`tableColumns-${column.label}`}
label={column.label}
checked={columnsShown.includes(column.elementKey!)}
onChange={(e) => {
onColumnChange(column.elementKey!, e.target.checked);
}}
id={`chbox-${column.label}`}
name={`chbox-${column.label}`}
value={column.label}
/>
);
})}
</div>
</Popover>
</Fragment>
);
};
return (
<Grid item xs={12} className={parentClassName}>
<Paper
className={`${classes.paper} ${noBackground ? classes.noBackground : ""}
${disabled ? classes.disabled : ""}
${
customPaperHeight !== ""
? customPaperHeight
: classes.defaultPaperHeight
}`}
>
{isLoading && (
<Grid container className={classes.loadingBox}>
<Grid item xs={12} style={{ textAlign: "center" }}>
{loadingMessage}
</Grid>
<Grid item xs={12}>
<LinearProgress />
</Grid>
</Grid>
)}
{columnsSelector && !isLoading && records.length > 0 && (
<div className={classes.overlayColumnSelection}>
{columnsSelection(columns)}
</div>
)}
{records && !isLoading && records.length > 0 ? (
// @ts-ignore
<InfiniteLoader
isRowLoaded={({ index }) => !!records[index]}
loadMoreRows={
infiniteScrollConfig
? infiniteScrollConfig.loadMoreRecords
: () => new Promise(() => true)
}
rowCount={
infiniteScrollConfig
? infiniteScrollConfig.recordsCount
: records.length
}
>
{({ onRowsRendered, registerChild }) => (
// @ts-ignore
<AutoSizer>
{({ width, height }: any) => {
const optionsWidth = calculateOptionsSize(
width,
itemActions
? itemActions.filter((el) => el.type !== "view").length
: 0
);
const hasSelect: boolean = !!(onSelect && selectedItems);
const hasOptions: boolean = !!(
(itemActions && itemActions.length > 1) ||
(itemActions &&
itemActions.length === 1 &&
itemActions[0].type !== "view")
);
return (
// @ts-ignore
<Table
ref={registerChild}
disableHeader={false}
headerClassName={"headerItem"}
headerHeight={40}
height={height}
noRowsRenderer={() => (
<Fragment>
{customEmptyMessage !== ""
? customEmptyMessage
: `There are no ${entityName} yet.`}
</Fragment>
)}
overscanRowCount={10}
rowHeight={40}
width={width}
rowCount={records.length}
rowGetter={({ index }) => records[index]}
onRowClick={({ rowData }) => {
clickAction(rowData);
}}
rowClassName={`rowLine ${findView ? "canClick" : ""} ${
!findView && textSelectable ? "canSelectText" : ""
}`}
onRowsRendered={onRowsRendered}
sort={sortConfig ? sortConfig.triggerSort : undefined}
sortBy={sortConfig ? sortConfig.currentSort : undefined}
sortDirection={
sortConfig ? sortConfig.currentDirection : undefined
}
scrollToIndex={
autoScrollToBottom ? records.length - 1 : -1
}
rowStyle={(r) => {
if (rowStyle) {
const returnElement = rowStyle(r);
if (typeof returnElement === "string") {
return get(TableRowPredefStyles, returnElement, {});
}
return returnElement;
}
return {};
}}
>
{hasSelect && (
// @ts-ignore
<Column
headerRenderer={() => (
<Fragment>
{onSelectAll ? (
<div className={classes.checkAllWrapper}>
<CheckboxWrapper
label={""}
onChange={onSelectAll}
value="all"
id={"selectAll"}
name={"selectAll"}
checked={
selectedItems?.length === records.length
}
/>
</div>
) : (
<Fragment>Select</Fragment>
)}
</Fragment>
)}
dataKey={`select-${idField}`}
width={selectWidth}
disableSort
cellRenderer={({ rowData }) => {
const isSelected = selectedItems
? selectedItems.includes(
isString(rowData) ? rowData : rowData[idField]
)
: false;
return (
<Checkbox
value={
isString(rowData) ? rowData : rowData[idField]
}
color="primary"
inputProps={{
"aria-label": "secondary checkbox",
}}
className="TableCheckbox"
checked={isSelected}
onChange={onSelect}
onClick={(e) => {
e.stopPropagation();
}}
checkedIcon={
<span
className={
radioSelection
? classes.radioSelectedIcon
: classes.checkedIcon
}
/>
}
icon={
<span
className={
radioSelection
? classes.radioUnselectedIcon
: classes.unCheckedIcon
}
/>
}
/>
);
}}
/>
)}
{generateColumnsMap(
columns,
width,
optionsWidth,
hasSelect,
hasOptions,
selectedItems || [],
idField,
columnsSelector,
columnsShown,
sortConfig ? sortConfig.currentSort : "",
sortConfig ? sortConfig.currentDirection : undefined
)}
{hasOptions && (
// @ts-ignore
<Column
dataKey={idField}
width={optionsWidth}
headerClassName="optionsAlignment"
className="optionsAlignment"
cellRenderer={({ rowData }) => {
const isSelected = selectedItems
? selectedItems.includes(
isString(rowData) ? rowData : rowData[idField]
)
: false;
return elementActions(
itemActions || [],
rowData,
isSelected,
idField
);
}}
/>
)}
</Table>
);
}}
</AutoSizer>
)}
</InfiniteLoader>
) : (
<Fragment>
{!isLoading && (
<div>
{customEmptyMessage !== ""
? customEmptyMessage
: `There are no ${entityName} yet.`}
</div>
)}
</Fragment>
)}
</Paper>
</Grid>
);
}
Example #3
| Source File: InfinityScroll.tsx From querybook with Apache License 2.0 | 4 votes |
|
function InfinityScrollComponent<T>({
labelField = 'name',
itemClass = '',
itemHeight = 24,
elements,
className,
onClick,
itemRenderer,
onLoadMore,
hasMore,
defaultListHeight,
autoSizerStyles,
}: React.PropsWithChildren<IInfinityScrollProps<T>>) {
const listRef = useRef<List>();
const rowRenderer = useCallback(
({
index, // Index of row
key, // Unique key within array of rendered rows
style, // Style object to be applied to row (to position it);
}: // This must be passed through to the rendered row element.
{
index: number;
key: string;
style: CSSProperties;
}) => {
if (index >= elements.length) {
return (
<div
key={key}
style={style}
className="InfiniteScroll-loader flex-center"
>
<LoadingRow />
</div>
);
}
const element = elements[index];
const content = itemRenderer ? (
itemRenderer(element)
) : (
<span
className={itemClass}
onClick={onClick.bind(null, element)}
>
{element[labelField]}
</span>
);
return (
<div key={key} style={style}>
{content}
</div>
);
},
[itemClass, itemRenderer, elements, labelField, onClick]
);
const isRowLoaded = useCallback(
({ index }: { index: number }) => index < elements.length,
[elements.length]
);
const handleLoadMoreRows = useCallback(
() =>
new Promise<void>(async (resolve) => {
try {
if (onLoadMore) {
await onLoadMore();
}
} finally {
resolve();
}
}),
[onLoadMore]
);
useEffect(() => {
if (listRef.current) {
listRef.current.forceUpdateGrid();
}
}, [elements]);
const rowCount = hasMore ? elements.length + 1 : elements.length;
return (
<InfiniteLoader
isRowLoaded={isRowLoaded}
loadMoreRows={handleLoadMoreRows}
rowCount={rowCount}
>
{({ onRowsRendered, registerChild }) => (
<AutoSizer style={autoSizerStyles}>
{({ height, width }) => (
<List
className={className}
onRowsRendered={onRowsRendered}
ref={(ref) => {
registerChild(ref);
listRef.current = ref;
}}
height={defaultListHeight ?? height}
width={width}
rowCount={rowCount}
rowHeight={itemHeight}
rowRenderer={rowRenderer}
/>
)}
</AutoSizer>
)}
</InfiniteLoader>
);
}
