@wavemaker-ai/react-runtime 1.0.0-next.27766

package/components/data/list/components/ListItem.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { ListItemContextType, WmListItemProps, ListItemData } from "../props";
+export declare const ListItemContext: React.Context<ListItemContextType<ListItemData>>;
+/**
+ * List Item Component
+ * Renders individual list items with context and drag-and-drop support
+ *
+ * Note: Widget naming (e.g., "Name_0", "Name_1") and internal widget flags
+ * are now handled at the codegen level. The renderItem function generates
+ * widgets with indexed names and data-internal-widget="true" directly.
+ */
+export declare const WmListItem: {
+    <T extends ListItemData = ListItemData>({ item, disableItem, itemClass, index, isFirst, isLast, children, trackId, onItemClick, onItemDoubleClick, onItemMouseEnter, onItemMouseLeave, tabIndex, isActive, enableReorder, id, direction, itemLayoutAttrs, }: WmListItemProps<T> & {
+        item: T;
+        direction?: "horizontal" | "vertical";
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/components/data/list/components/ListItem.js

@@ -0,0 +1,173 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { jsx } from "react/jsx-runtime";
+import { createContext, useRef, useMemo, useCallback } from "react";
+import clsx from "clsx";
+import { SortableItem } from "./ListDND";
+const defaultItemRef = { current: null };
+const ListItemContext = createContext({
+  item: {},
+  index: -1,
+  itemRef: defaultItemRef,
+  isFirst: false,
+  isLast: false,
+  currentItemWidgets: {}
+});
+const buildItemClasses = (itemClass, isActive, disableItem, isFirst, isLast) => {
+  return clsx("app-list-item", itemClass, {
+    active: isActive,
+    disabled: disableItem,
+    "disable-item": disableItem,
+    "first-item": isFirst,
+    "last-item": isLast
+  });
+};
+const WmListItem = ({
+  item,
+  disableItem = false,
+  itemClass = "",
+  index = 0,
+  isFirst = false,
+  isLast = false,
+  children,
+  trackId,
+  onItemClick,
+  onItemDoubleClick,
+  onItemMouseEnter,
+  onItemMouseLeave,
+  tabIndex,
+  isActive = false,
+  enableReorder = false,
+  id,
+  direction = "vertical",
+  itemLayoutAttrs
+}) => {
+  const itemRef = useRef(null);
+  const handleClickCapture = useCallback(
+    (event) => {
+      if (!disableItem && onItemClick) {
+        onItemClick(event, item);
+      }
+    },
+    [disableItem, onItemClick, item]
+  );
+  const handleDoubleClickCapture = useCallback(
+    (event) => {
+      if (!disableItem && onItemDoubleClick) {
+        onItemDoubleClick(event, item);
+      }
+    },
+    [disableItem, onItemDoubleClick, item]
+  );
+  const handleMouseEnter = useCallback(
+    (event) => {
+      if (!disableItem && onItemMouseEnter) {
+        onItemMouseEnter(event, item);
+      }
+    },
+    [disableItem, onItemMouseEnter, item]
+  );
+  const handleMouseLeave = useCallback(
+    (event) => {
+      if (!disableItem && onItemMouseLeave) {
+        onItemMouseLeave(event, item);
+      }
+    },
+    [disableItem, onItemMouseLeave, item]
+  );
+  const itemClasses = useMemo(
+    () => buildItemClasses(itemClass, isActive, disableItem, isFirst, isLast),
+    [itemClass, isActive, disableItem, isFirst, isLast]
+  );
+  const contextValue = useMemo(
+    () => ({
+      item,
+      index,
+      itemRef,
+      isFirst,
+      isLast,
+      currentItemWidgets: {}
+    }),
+    [item, index, isFirst, isLast]
+  );
+  const dynamicAutoLayoutStyles = useMemo(
+    () => __spreadValues(__spreadValues(__spreadValues({}, (itemLayoutAttrs == null ? void 0 : itemLayoutAttrs.positionvalue) ? { inset: itemLayoutAttrs.positionvalue } : {}), (itemLayoutAttrs == null ? void 0 : itemLayoutAttrs.zindex) ? { zIndex: itemLayoutAttrs.zindex } : {}), (itemLayoutAttrs == null ? void 0 : itemLayoutAttrs.position) ? { position: itemLayoutAttrs.position } : {}),
+    [itemLayoutAttrs]
+  );
+  const listItemContent = useMemo(
+    () => /* @__PURE__ */ jsx(
+      "li",
+      __spreadProps(__spreadValues({
+        ref: itemRef,
+        className: clsx(
+          itemClasses,
+          itemLayoutAttrs == null ? void 0 : itemLayoutAttrs.layoutClassName,
+          itemLayoutAttrs == null ? void 0 : itemLayoutAttrs.className
+        ),
+        style: dynamicAutoLayoutStyles,
+        onClickCapture: handleClickCapture,
+        onDoubleClickCapture: handleDoubleClickCapture,
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        tabIndex,
+        "data-track-id": trackId,
+        "data-item-index": index,
+        "data-item-active": isActive,
+        "aria-selected": isActive,
+        role: "option"
+      }, { listitemindex: index }), {
+        children: /* @__PURE__ */ jsx(ListItemContext.Provider, { value: contextValue, children })
+      })
+    ),
+    [
+      itemClasses,
+      handleClickCapture,
+      handleDoubleClickCapture,
+      handleMouseEnter,
+      handleMouseLeave,
+      tabIndex,
+      trackId,
+      index,
+      isActive,
+      contextValue,
+      children,
+      itemLayoutAttrs
+    ]
+  );
+  if (enableReorder) {
+    const sortableId = id || trackId || `item_${index}`;
+    return /* @__PURE__ */ jsx(
+      SortableItem,
+      {
+        id: sortableId,
+        enableReorder,
+        disableItem,
+        direction,
+        children: listItemContent
+      }
+    );
+  }
+  return listItemContent;
+};
+WmListItem.displayName = "WmListItem";
+export {
+  ListItemContext,
+  WmListItem
+};

package/components/data/list/components/ListItemWithTemplate.d.ts

@@ -0,0 +1,6 @@
+import { ListItemData } from "../props";
+import { ListItemWithTemplateProps } from "./props";
+/**
+ * Single list item component with template rendering
+ */
+export declare const ListItemWithTemplate: <T extends ListItemData = ListItemData>({ item, index, globalIndex, itemId, isFirst, isLast, disableitem, itemclass, itemsPerRowClass, name, tabIndex, isActive, enablereorder, direction, renderItem, itemTemplate, onItemClick, onItemDoubleClick, onItemMouseEnter, onItemMouseLeave, itemAttrs, standalone, }: ListItemWithTemplateProps<T>) => import("react/jsx-runtime").JSX.Element;

package/components/data/list/components/ListItemWithTemplate.js

@@ -0,0 +1,102 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useRef, useEffect, useMemo } from "react";
+import clsx from "clsx";
+import { WmListItem } from "./ListItem";
+import { MediaWmListtemplate } from "../templates/media-template";
+import { resolveDisableItem } from "../utils/list-helpers";
+import { useWidgetProxy } from "../../../../context/WidgetProvider";
+import isPlainObject from "lodash-es/isPlainObject";
+import isEmpty from "lodash-es/isEmpty";
+const ListItemWithTemplate = ({
+  item,
+  index,
+  globalIndex,
+  itemId,
+  isFirst,
+  isLast,
+  disableitem,
+  itemclass,
+  itemsPerRowClass,
+  name,
+  tabIndex,
+  isActive,
+  enablereorder,
+  direction = "vertical",
+  renderItem,
+  itemTemplate,
+  onItemClick,
+  onItemDoubleClick,
+  onItemMouseEnter,
+  onItemMouseLeave,
+  itemAttrs,
+  standalone = false
+}) => {
+  const WidgetProxy = useWidgetProxy(void 0, standalone);
+  const widgetCacheRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    widgetCacheRef.current.clear();
+  }, [WidgetProxy, name]);
+  const getCurrentItemWidgets = useCallback(
+    ($index) => {
+      const cached = widgetCacheRef.current.get($index);
+      if (cached && !isEmpty(cached)) {
+        return cached;
+      }
+      const items = {};
+      const prefix = `${name}_${$index}_`;
+      for (const key in WidgetProxy) {
+        const [listName, idx] = key.split("_");
+        if (key.startsWith(prefix)) {
+          const widget = WidgetProxy[key];
+          if (parseInt(idx) === $index && listName === name) {
+            items[widget.name] = widget;
+          }
+        }
+      }
+      if (!isEmpty(items)) {
+        widgetCacheRef.current.set($index, items);
+      }
+      return items;
+    },
+    [WidgetProxy, name]
+  );
+  if (isPlainObject(item)) {
+    item.selected = isActive;
+  }
+  const templateContent = renderItem ? renderItem(item, globalIndex != null ? globalIndex : index, WidgetProxy[name], getCurrentItemWidgets) : itemTemplate || /* @__PURE__ */ jsx(MediaWmListtemplate, {});
+  const resolvedItemClass = useMemo(() => {
+    return typeof itemclass === "function" ? itemclass(item) : itemclass;
+  }, [itemclass, item]);
+  const itemLayoutAttrs = itemAttrs ? itemAttrs(item, globalIndex != null ? globalIndex : index) : void 0;
+  const resolvedDisableItem = useMemo(() => {
+    return resolveDisableItem(disableitem, item, globalIndex != null ? globalIndex : index);
+  }, [disableitem, item, globalIndex, index]);
+  return /* @__PURE__ */ jsx(
+    WmListItem,
+    {
+      item,
+      disableItem: resolvedDisableItem,
+      itemClass: clsx(resolvedItemClass, itemsPerRowClass),
+      index: globalIndex != null ? globalIndex : index,
+      isFirst,
+      isLast,
+      trackId: itemId,
+      onItemClick,
+      onItemDoubleClick,
+      onItemMouseEnter,
+      onItemMouseLeave,
+      tabIndex,
+      isActive,
+      name: `${name}_item_${globalIndex != null ? globalIndex : index}`,
+      enableReorder: enablereorder,
+      id: itemId,
+      direction,
+      itemLayoutAttrs,
+      children: templateContent
+    },
+    itemId
+  );
+};
+export {
+  ListItemWithTemplate
+};

package/components/data/list/components/ListItems.d.ts

@@ -0,0 +1,7 @@
+import { ListItemsProps } from "./props";
+import { ListItemData } from "../props";
+/**
+ * Main ListItems component - orchestrates rendering of list items
+ * with support for grouping, pagination, and on-demand loading
+ */
+export declare const ListItems: <T extends ListItemData = ListItemData>({ items, groupedData, groupby, navigation, currentPage, pagesize, visibleItems, orderby, disableitem, itemclass, itemsPerRowClass, direction, enablereorder, activeItems, name, tabIndex, renderItem, itemTemplate, nodatamessage, ondemandmessage, loadingicon, loadingiconurl, loadingdatamsg, paginationclass, isLoadingMore, prefabName, collapsible, showcount, groupCollapsed, handleListItemClick, handleListItemDoubleClick, handleListItemMouseEnter, handleListItemMouseLeave, handleDragEnd, handleLoadMore, handleHeaderClick, onBeforedatarender, onRender, widgetInstance, rawDataset, datasource, totalItems, isServerSidePagination, showNavigation, itemAttrs, hasListGroupAutoLayout, standalone, }: ListItemsProps<T>) => import("react/jsx-runtime").JSX.Element;

package/components/data/list/components/ListItems.js

@@ -0,0 +1,221 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useEffect } from "react";
+import { LoadMoreButton } from "./LoadMoreButton";
+import { StandardListItems } from "./StandardListItems";
+import { GroupedListItems } from "./GroupedListItems";
+import { LIST_NAVIGATION_TYPES } from "../utils/constants";
+import { useCurrentPageItems, usePaginatedGroupedData } from "../hooks";
+const ListItems = ({
+  items,
+  groupedData,
+  groupby,
+  navigation,
+  currentPage,
+  pagesize,
+  visibleItems,
+  orderby,
+  disableitem,
+  itemclass,
+  itemsPerRowClass,
+  direction,
+  enablereorder,
+  activeItems,
+  name,
+  tabIndex,
+  renderItem,
+  itemTemplate,
+  nodatamessage,
+  ondemandmessage,
+  loadingicon,
+  loadingiconurl,
+  loadingdatamsg,
+  paginationclass,
+  isLoadingMore,
+  prefabName,
+  collapsible,
+  showcount,
+  groupCollapsed,
+  handleListItemClick,
+  handleListItemDoubleClick,
+  handleListItemMouseEnter,
+  handleListItemMouseLeave,
+  handleDragEnd,
+  handleLoadMore,
+  handleHeaderClick,
+  onBeforedatarender,
+  onRender,
+  widgetInstance,
+  rawDataset,
+  datasource,
+  totalItems,
+  isServerSidePagination,
+  showNavigation,
+  itemAttrs,
+  hasListGroupAutoLayout,
+  standalone = false
+}) => {
+  const isServerPaginated = !!isServerSidePagination;
+  const paginationMeta = datasource == null ? void 0 : datasource.pagination;
+  const rawCurrentPageItems = useCurrentPageItems({
+    items: rawDataset || [],
+    navigation,
+    currentPage,
+    pagesize,
+    visibleItems,
+    isServerPaginated
+    // Pass flag to indicate server pagination
+  });
+  const currentPageItems = useCurrentPageItems({
+    items,
+    navigation,
+    currentPage,
+    pagesize,
+    visibleItems,
+    isServerPaginated
+    // Pass flag to indicate server pagination
+  });
+  const paginatedGroupedData = usePaginatedGroupedData({
+    groupedData: groupedData || [],
+    navigation,
+    currentPage,
+    pagesize,
+    visibleItems,
+    isServerSidePagination: isServerPaginated
+  });
+  const rawCurrentItemsKey = useMemo(
+    () => JSON.stringify(rawCurrentPageItems.currentItems),
+    [rawCurrentPageItems.currentItems]
+  );
+  const currentItemsKey = useMemo(
+    () => JSON.stringify(currentPageItems.currentItems),
+    [currentPageItems.currentItems]
+  );
+  const paginatedGroupedDataKey = useMemo(
+    () => JSON.stringify(paginatedGroupedData),
+    [paginatedGroupedData]
+  );
+  useEffect(() => {
+    if (onBeforedatarender && widgetInstance) {
+      onBeforedatarender(widgetInstance, rawCurrentPageItems.currentItems);
+    }
+  }, [rawCurrentItemsKey, groupby]);
+  useEffect(() => {
+    if (onRender) {
+      if (groupby) {
+        const currentPageGroupedItems = paginatedGroupedData.reduce((acc, group) => {
+          return acc.concat(group.data);
+        }, []);
+        onRender(widgetInstance, currentPageGroupedItems);
+      } else {
+        onRender(widgetInstance, currentPageItems.currentItems);
+      }
+    }
+  }, []);
+  const totalGroupedItems = useMemo(() => {
+    if (!groupedData || !Array.isArray(groupedData)) return 0;
+    return groupedData.reduce((total, group) => {
+      var _a;
+      return total + (((_a = group.data) == null ? void 0 : _a.length) || 0);
+    }, 0);
+  }, [groupedData]);
+  const shouldShowLoadMore = useMemo(() => {
+    if (navigation !== LIST_NAVIGATION_TYPES.ON_DEMAND) {
+      return false;
+    }
+    if (isServerPaginated && (paginationMeta == null ? void 0 : paginationMeta.last) !== void 0) {
+      return !paginationMeta.last;
+    }
+    if (isServerPaginated && totalItems !== void 0 && datasource) {
+      if (groupby) {
+        return totalGroupedItems < totalItems;
+      } else {
+        return items.length < totalItems;
+      }
+    }
+    if (groupby) {
+      return visibleItems < totalGroupedItems;
+    } else {
+      return visibleItems < items.length;
+    }
+  }, [
+    navigation,
+    isServerPaginated,
+    paginationMeta == null ? void 0 : paginationMeta.last,
+    totalItems,
+    datasource,
+    groupby,
+    totalGroupedItems,
+    items.length,
+    visibleItems
+  ]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    groupby ? /* @__PURE__ */ jsx(
+      GroupedListItems,
+      {
+        groupedData: groupedData || [],
+        paginatedGroupedData,
+        direction,
+        disableitem,
+        itemclass,
+        itemsPerRowClass,
+        name,
+        tabIndex,
+        activeItems,
+        collapsible,
+        showcount,
+        groupCollapsed,
+        renderItem,
+        itemTemplate,
+        nodatamessage,
+        onItemClick: handleListItemClick,
+        onItemDoubleClick: handleListItemDoubleClick,
+        onItemMouseEnter: handleListItemMouseEnter,
+        onItemMouseLeave: handleListItemMouseLeave,
+        onHeaderClick: handleHeaderClick,
+        itemAttrs,
+        hasListGroupAutoLayout,
+        standalone
+      }
+    ) : /* @__PURE__ */ jsx(
+      StandardListItems,
+      {
+        items,
+        currentPageItems,
+        direction,
+        enablereorder,
+        disableitem,
+        itemclass,
+        itemsPerRowClass,
+        name,
+        tabIndex,
+        activeItems,
+        renderItem,
+        itemTemplate,
+        nodatamessage,
+        onItemClick: handleListItemClick,
+        onItemDoubleClick: handleListItemDoubleClick,
+        onItemMouseEnter: handleListItemMouseEnter,
+        onItemMouseLeave: handleListItemMouseLeave,
+        onDragEnd: handleDragEnd,
+        itemAttrs,
+        standalone
+      }
+    ),
+    shouldShowLoadMore && showNavigation !== false && /* @__PURE__ */ jsx(
+      LoadMoreButton,
+      {
+        paginationclass,
+        isLoadingMore,
+        loadingicon,
+        loadingiconurl,
+        loadingdatamsg,
+        ondemandmessage,
+        onLoadMore: handleLoadMore,
+        prefabName
+      }
+    )
+  ] });
+};
+export {
+  ListItems
+};

package/components/data/list/components/ListPagination.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { ListPaginationProps } from "./props";
+/**
+ * List Pagination Component
+ * Handles pagination for the list component with improved type safety and structure
+ */
+export declare const ListPagination: React.FC<ListPaginationProps>;

package/components/data/list/components/ListPagination.js

@@ -0,0 +1,157 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import Box from "@mui/material/Box";
+import clsx from "clsx";
+import WmPagination from "../../pagination";
+import { LIST_NAVIGATION_TYPES } from "../utils/constants";
+const mapNavigationType = (navigation) => {
+  switch (navigation) {
+    case LIST_NAVIGATION_TYPES.BASIC:
+    case LIST_NAVIGATION_TYPES.PAGER:
+    case LIST_NAVIGATION_TYPES.CLASSIC:
+    case LIST_NAVIGATION_TYPES.SCROLL:
+      return navigation;
+    case LIST_NAVIGATION_TYPES.ADVANCED:
+      return LIST_NAVIGATION_TYPES.CLASSIC;
+    default:
+      return LIST_NAVIGATION_TYPES.BASIC;
+  }
+};
+const shouldHidePagination = (navigation, allowpagesizechange, datasetLength, pagesize, paginationMeta, totalItems) => {
+  const isNone = String(navigation) === String(LIST_NAVIGATION_TYPES.NONE) || navigation === "None";
+  if (isNone) {
+    return true;
+  }
+  if (navigation === LIST_NAVIGATION_TYPES.SCROLL) {
+    return false;
+  }
+  if (paginationMeta) {
+    if (paginationMeta.totalPages !== void 0 && paginationMeta.totalPages > 1) {
+      return false;
+    }
+    if (paginationMeta.totalElements !== void 0 && paginationMeta.totalElements > pagesize) {
+      return false;
+    }
+  }
+  if (totalItems !== void 0 && totalItems > pagesize) {
+    return false;
+  }
+  if (!allowpagesizechange && datasetLength <= pagesize) {
+    return true;
+  }
+  if (allowpagesizechange) {
+    return false;
+  }
+  return datasetLength === 0;
+};
+const ListPagination = (props) => {
+  const {
+    name,
+    navigation,
+    orderedDataset,
+    pagesize,
+    currentPage,
+    navigationalign,
+    showrecordcount,
+    maxsize,
+    boundarylinks,
+    paginationclass,
+    allowpagesizechange = true,
+    pagesizeoptions = "5,10,20,50,100",
+    onPaginationChange,
+    onSetRecord,
+    onPageSizeChange,
+    listener,
+    paginationMeta,
+    totalItems,
+    datasource,
+    isLoadingMore,
+    setIsLoadingMore,
+    isServerSidePagination,
+    listDirection,
+    scrollContainerRef,
+    sentinelRef,
+    onDataUpdate
+  } = props;
+  const hidePagination = useMemo(
+    () => shouldHidePagination(
+      navigation,
+      allowpagesizechange,
+      orderedDataset.length,
+      pagesize,
+      paginationMeta,
+      totalItems
+    ),
+    [
+      navigation,
+      allowpagesizechange,
+      orderedDataset.length,
+      pagesize,
+      paginationMeta,
+      props.totalItems
+    ]
+  );
+  const paginationNavigation = useMemo(() => mapNavigationType(navigation), [navigation]);
+  const handlePaginationChange = useMemo(
+    () => (event, widget, index) => {
+      onPaginationChange(event, widget, index);
+    },
+    [onPaginationChange]
+  );
+  const handleSetRecord = useMemo(
+    () => (event, widget, data, pageInfo) => {
+      var _a;
+      onSetRecord(event, widget, (_a = pageInfo == null ? void 0 : pageInfo.currentPage) != null ? _a : 1, data);
+    },
+    [onSetRecord]
+  );
+  const paginationDataset = useMemo(
+    () => navigation === LIST_NAVIGATION_TYPES.SCROLL ? orderedDataset : totalItems ? Array(totalItems).fill(null) : orderedDataset,
+    [navigation, orderedDataset, totalItems]
+  );
+  if (hidePagination) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      component: "div",
+      className: clsx("pagination-container", "app-datanavigator", `text-${navigationalign}`),
+      children: /* @__PURE__ */ jsx(
+        WmPagination,
+        {
+          name: `${name}_pagination`,
+          dataset: paginationDataset,
+          maxResults: pagesize,
+          currentPage,
+          navigation: paginationNavigation,
+          navigationalign,
+          showrecordcount,
+          maxsize,
+          boundarylinks,
+          directionlinks: true,
+          allowpagesizechange,
+          pagesizeoptions,
+          className: clsx("pagination", paginationclass),
+          listener,
+          onPaginationChange: handlePaginationChange,
+          onSetRecord: handleSetRecord,
+          onPageSizeChange,
+          paginationMeta,
+          totalItems,
+          datasource,
+          isLoadingMore,
+          setIsLoadingMore,
+          isServerSidePagination,
+          listDirection,
+          scrollContainerRef,
+          sentinelRef,
+          onDataUpdate
+        }
+      )
+    }
+  );
+};
+export {
+  ListPagination
+};

package/components/data/list/components/LoadMoreButton.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { LoadMoreButtonProps } from "./props";
+/**
+ * Load more button component for on-demand pagination
+ */
+export declare const LoadMoreButton: React.FC<LoadMoreButtonProps>;