@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/data/list/components/StandardListItems.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StandardListItems = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _ListDND = require("./ListDND");
+var _ListItemWithTemplate = require("./ListItemWithTemplate");
+var _ListContainer = require("./ListContainer");
+var _NoDataMessage = require("./NoDataMessage");
+var _some = _interopRequireDefault(require("lodash-es/some"));
+var __jsx = _react["default"].createElement;
+/**
+ * Standard list items renderer for non-grouped lists
+ */
+var StandardListItems = exports.StandardListItems = function StandardListItems(_ref) {
+  var items = _ref.items,
+    currentPageItems = _ref.currentPageItems,
+    direction = _ref.direction,
+    enablereorder = _ref.enablereorder,
+    disableitem = _ref.disableitem,
+    itemclass = _ref.itemclass,
+    itemsPerRowClass = _ref.itemsPerRowClass,
+    name = _ref.name,
+    tabIndex = _ref.tabIndex,
+    activeItems = _ref.activeItems,
+    renderItem = _ref.renderItem,
+    itemTemplate = _ref.itemTemplate,
+    nodatamessage = _ref.nodatamessage,
+    onItemClick = _ref.onItemClick,
+    onItemDoubleClick = _ref.onItemDoubleClick,
+    onItemMouseEnter = _ref.onItemMouseEnter,
+    onItemMouseLeave = _ref.onItemMouseLeave,
+    onDragEnd = _ref.onDragEnd,
+    itemAttrs = _ref.itemAttrs,
+    _ref$standalone = _ref.standalone,
+    standalone = _ref$standalone === void 0 ? false : _ref$standalone;
+  if (!items || !Array.isArray(items) || items.length === 0) {
+    return __jsx(_NoDataMessage.NoDataMessage, {
+      message: nodatamessage
+    });
+  }
+  var currentItems = currentPageItems.currentItems,
+    startIndex = currentPageItems.startIndex;
+  var listItems = currentItems.map(function (item, index) {
+    var globalIndex = startIndex + index;
+    var itemId = (0, _ListDND.getItemId)(item, globalIndex);
+    var isFirst = index === 0;
+    var isLast = index === currentItems.length - 1;
+    var isActive = (Array.isArray(activeItems) || activeItems instanceof Set) && (0, _some["default"])(Array.from(activeItems), function (active) {
+      return active._wmListItemId === item._wmListItemId;
+    });
+    return __jsx(_ListItemWithTemplate.ListItemWithTemplate, {
+      key: itemId,
+      item: item,
+      index: index,
+      globalIndex: globalIndex,
+      itemId: itemId,
+      isFirst: isFirst,
+      isLast: isLast,
+      disableitem: disableitem,
+      itemclass: itemclass,
+      itemsPerRowClass: itemsPerRowClass,
+      name: name,
+      tabIndex: tabIndex,
+      isActive: isActive,
+      enablereorder: enablereorder,
+      direction: direction,
+      renderItem: renderItem,
+      itemTemplate: itemTemplate,
+      onItemClick: onItemClick,
+      onItemDoubleClick: onItemDoubleClick,
+      onItemMouseEnter: onItemMouseEnter,
+      onItemMouseLeave: onItemMouseLeave,
+      itemAttrs: itemAttrs,
+      standalone: standalone
+    });
+  });
+  return __jsx(_ListContainer.ListContainer, {
+    direction: direction,
+    enablereorder: enablereorder,
+    items: currentItems,
+    startIndex: startIndex,
+    onDragEnd: onDragEnd
+  }, listItems);
+};

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

@@ -0,0 +1,12 @@
+export { ListHeader } from "./ListHeader";
+export { ListPagination } from "./ListPagination";
+export { ListItems } from "./ListItems";
+export { getItemId, DndWrapper, SortableItem, dragStyles, useDragAndDrop } from "./ListDND";
+export { ListItemContext, WmListItem } from "./ListItem";
+export { NoDataMessage } from "./NoDataMessage";
+export { LoadMoreButton } from "./LoadMoreButton";
+export { GroupHeader } from "./GroupHeader";
+export { ListContainer } from "./ListContainer";
+export { ListItemWithTemplate } from "./ListItemWithTemplate";
+export { StandardListItems } from "./StandardListItems";
+export { GroupedListItems } from "./GroupedListItems";

package/components/data/list/components/index.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DndWrapper", {
+  enumerable: true,
+  get: function get() {
+    return _ListDND.DndWrapper;
+  }
+});
+Object.defineProperty(exports, "GroupHeader", {
+  enumerable: true,
+  get: function get() {
+    return _GroupHeader.GroupHeader;
+  }
+});
+Object.defineProperty(exports, "GroupedListItems", {
+  enumerable: true,
+  get: function get() {
+    return _GroupedListItems.GroupedListItems;
+  }
+});
+Object.defineProperty(exports, "ListContainer", {
+  enumerable: true,
+  get: function get() {
+    return _ListContainer.ListContainer;
+  }
+});
+Object.defineProperty(exports, "ListHeader", {
+  enumerable: true,
+  get: function get() {
+    return _ListHeader.ListHeader;
+  }
+});
+Object.defineProperty(exports, "ListItemContext", {
+  enumerable: true,
+  get: function get() {
+    return _ListItem.ListItemContext;
+  }
+});
+Object.defineProperty(exports, "ListItemWithTemplate", {
+  enumerable: true,
+  get: function get() {
+    return _ListItemWithTemplate.ListItemWithTemplate;
+  }
+});
+Object.defineProperty(exports, "ListItems", {
+  enumerable: true,
+  get: function get() {
+    return _ListItems.ListItems;
+  }
+});
+Object.defineProperty(exports, "ListPagination", {
+  enumerable: true,
+  get: function get() {
+    return _ListPagination.ListPagination;
+  }
+});
+Object.defineProperty(exports, "LoadMoreButton", {
+  enumerable: true,
+  get: function get() {
+    return _LoadMoreButton.LoadMoreButton;
+  }
+});
+Object.defineProperty(exports, "NoDataMessage", {
+  enumerable: true,
+  get: function get() {
+    return _NoDataMessage.NoDataMessage;
+  }
+});
+Object.defineProperty(exports, "SortableItem", {
+  enumerable: true,
+  get: function get() {
+    return _ListDND.SortableItem;
+  }
+});
+Object.defineProperty(exports, "StandardListItems", {
+  enumerable: true,
+  get: function get() {
+    return _StandardListItems.StandardListItems;
+  }
+});
+Object.defineProperty(exports, "WmListItem", {
+  enumerable: true,
+  get: function get() {
+    return _ListItem.WmListItem;
+  }
+});
+Object.defineProperty(exports, "dragStyles", {
+  enumerable: true,
+  get: function get() {
+    return _ListDND.dragStyles;
+  }
+});
+Object.defineProperty(exports, "getItemId", {
+  enumerable: true,
+  get: function get() {
+    return _ListDND.getItemId;
+  }
+});
+Object.defineProperty(exports, "useDragAndDrop", {
+  enumerable: true,
+  get: function get() {
+    return _ListDND.useDragAndDrop;
+  }
+});
+var _ListHeader = require("./ListHeader");
+var _ListPagination = require("./ListPagination");
+var _ListItems = require("./ListItems");
+var _ListDND = require("./ListDND");
+var _ListItem = require("./ListItem");
+var _NoDataMessage = require("./NoDataMessage");
+var _LoadMoreButton = require("./LoadMoreButton");
+var _GroupHeader = require("./GroupHeader");
+var _ListContainer = require("./ListContainer");
+var _ListItemWithTemplate = require("./ListItemWithTemplate");
+var _StandardListItems = require("./StandardListItems");
+var _GroupedListItems = require("./GroupedListItems");

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

@@ -0,0 +1,245 @@
+import React from "react";
+import { GroupedDataItem } from "../hooks";
+import { INavigation, IDirection, IAlignment, ListItemData, ListPaginationChangeHandler, ListSetRecordHandler, ListBeforeDataRenderHandler } from "../props";
+import { DragEndEvent } from "@dnd-kit/core";
+export type DefaultEventHandler<T = ListItemData> = (event: React.MouseEvent, item: T) => void;
+export interface ListPaginationProps {
+    name: string;
+    navigation: INavigation;
+    orderedDataset: ListItemData[];
+    pagesize: number;
+    currentPage?: number;
+    navigationalign: IAlignment;
+    showrecordcount: boolean;
+    maxsize: number;
+    boundarylinks: boolean;
+    paginationclass: string;
+    allowpagesizechange?: boolean;
+    pagesizeoptions?: string;
+    widgetInstance?: unknown;
+    onPaginationChange: ListPaginationChangeHandler;
+    onSetRecord: ListSetRecordHandler<ListItemData>;
+    onPageSizeChange?: (pageSize: number) => void;
+    listener: any;
+    paginationMeta?: IPaginationMeta;
+    totalItems?: number;
+    datasource?: any;
+    isLoadingMore?: boolean;
+    setIsLoadingMore?: (loading: boolean) => void;
+    isServerSidePagination?: boolean;
+    /** List direction: "row" | "horizontal" for horizontal scroll (load more on scroll right); vertical/column use sentinel */
+    listDirection?: string;
+    /** Ref to list scroll container (for Scroll + row: observer root) */
+    scrollContainerRef?: React.RefObject<HTMLElement | null>;
+    /** Ref for scroll sentinel (pagination sets for both vertical and horizontal) */
+    sentinelRef?: React.RefObject<HTMLElement | null>;
+    /** Called when pagination has new accumulated data (Scroll/On-Demand); list uses this to preserve old + new data */
+    onDataUpdate?: (data: ListItemData[]) => void;
+}
+export interface IPaginationMeta {
+    totalPages: number;
+    totalElements: number;
+    last: boolean;
+    sort: Array<any>;
+    numberOfElements: number;
+    first: boolean;
+    size: number;
+    number: number;
+    empty: boolean;
+}
+export interface ListItemsProps<T = ListItemData> {
+    items: T[];
+    groupedData?: GroupedDataItem<T>[];
+    groupby?: string;
+    navigation: INavigation;
+    currentPage: number;
+    pagesize: number;
+    visibleItems: number;
+    orderby?: string;
+    startIndex?: number;
+    endIndex?: number;
+    disableitem: boolean;
+    itemclass: string | ((item: T) => string | null | undefined);
+    itemsPerRowClass: string;
+    direction: IDirection;
+    enablereorder: boolean;
+    activeItems: Set<T>;
+    name: string;
+    tabIndex?: number;
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    itemTemplate?: React.ReactNode;
+    nodatamessage: string;
+    ondemandmessage: string;
+    loadingicon: string;
+    loadingdatamsg: string;
+    paginationclass: string;
+    isLoadingMore: boolean;
+    collapsible: boolean;
+    showcount: boolean;
+    groupCollapsed: Record<string, boolean>;
+    handleListItemClick: DefaultEventHandler;
+    handleListItemDoubleClick: DefaultEventHandler;
+    handleListItemMouseEnter: DefaultEventHandler;
+    handleListItemMouseLeave: DefaultEventHandler;
+    handleDragEnd: (event: DragEndEvent) => void;
+    handleLoadMore: () => void;
+    handleHeaderClick: (groupKey: string) => void;
+    onBeforedatarender?: ListBeforeDataRenderHandler<T>;
+    onRender?: ListBeforeDataRenderHandler<T>;
+    widgetInstance?: unknown;
+    rawDataset?: T[];
+    datasource?: any;
+    totalItems?: number;
+    isServerSidePagination?: boolean;
+    showNavigation?: boolean;
+    itemAttrs?: (item: ListItemData, index: number) => Record<string, unknown>;
+    /** Angular `[class.list-group-autolayout]` parity for grouped inner `<ul>`s */
+    hasListGroupAutoLayout?: boolean;
+    /** When true, child rows skip page WidgetProvider proxy (standalone list). */
+    standalone?: boolean;
+}
+export interface ListHeaderProps {
+    title?: string;
+    subheading?: string;
+    iconclass?: string;
+}
+export interface ListTemplateProps {
+    children: React.ReactNode;
+    layout?: string;
+    name?: string;
+}
+export interface DndWrapperProps<T = ListItemData> {
+    items: T[];
+    direction: IDirection;
+    startIndex: number;
+    onDragEnd: (event: DragEndEvent) => void;
+    children: React.ReactNode;
+}
+export interface SortableItemProps {
+    id: string;
+    index: number;
+    children: React.ReactNode;
+}
+export interface NoDataMessageProps {
+    message: string;
+    className?: string;
+}
+export interface LoadMoreButtonProps {
+    paginationclass: string;
+    isLoadingMore: boolean;
+    loadingicon: string;
+    loadingdatamsg: string;
+    ondemandmessage: string;
+    onLoadMore: () => void;
+}
+export interface GroupHeaderProps {
+    groupKey: string;
+    displayCount: number;
+    isCollapsed: boolean;
+    collapsible: boolean;
+    showcount: boolean;
+    onHeaderClick: (groupKey: string) => void;
+}
+export interface ListContainerProps<T extends ListItemData = ListItemData> {
+    direction: string;
+    enablereorder: boolean;
+    items: T[];
+    startIndex: number;
+    children: React.ReactNode;
+    onDragEnd: (event: DragEndEvent) => void;
+}
+export interface ListItemWithTemplateProps<T extends ListItemData = ListItemData> {
+    item: T;
+    index: number;
+    globalIndex?: number;
+    itemId: string;
+    isFirst: boolean;
+    isLast: boolean;
+    disableitem: boolean;
+    itemclass: string | ((item: T, index?: number) => string | null | undefined);
+    itemsPerRowClass: string;
+    name: string;
+    tabIndex?: number;
+    isActive: boolean;
+    enablereorder?: boolean;
+    direction?: string;
+    renderItem?: (item: T, index: number, list?: T[], currentItemWidgets?: Record<string, any>) => React.ReactNode;
+    itemTemplate?: React.ReactNode;
+    onItemClick: DefaultEventHandler;
+    onItemDoubleClick: DefaultEventHandler;
+    onItemMouseEnter: DefaultEventHandler;
+    onItemMouseLeave: DefaultEventHandler;
+    itemAttrs?: (item: ListItemData, index: number) => Record<string, unknown>;
+    standalone?: boolean;
+}
+export interface StandardListItemsProps<T extends ListItemData = ListItemData> {
+    items: T[];
+    currentPageItems: CurrentPageItemsResult<T>;
+    direction: string;
+    enablereorder: boolean;
+    disableitem: boolean;
+    itemclass: string | ((item: T, index?: number) => string | null | undefined);
+    itemsPerRowClass: string;
+    name: string;
+    tabIndex?: number;
+    activeItems: Set<T>;
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    itemTemplate?: React.ReactNode;
+    nodatamessage: string;
+    onItemClick: DefaultEventHandler;
+    onItemDoubleClick: DefaultEventHandler;
+    onItemMouseEnter: DefaultEventHandler;
+    onItemMouseLeave: DefaultEventHandler;
+    onDragEnd: (event: DragEndEvent) => void;
+    itemAttrs?: (item: ListItemData, index: number) => Record<string, unknown>;
+    standalone?: boolean;
+}
+export interface GroupedListItemsProps<T extends ListItemData = ListItemData> {
+    groupedData: GroupedDataItem<T>[];
+    paginatedGroupedData: PaginatedGroupedDataItem<T>[];
+    direction: string;
+    disableitem: boolean;
+    itemclass: string | ((item: T, index?: number) => string | null | undefined);
+    itemsPerRowClass: string;
+    name: string;
+    tabIndex?: number;
+    activeItems: Set<T>;
+    collapsible: boolean;
+    showcount: boolean;
+    groupCollapsed: Record<string, boolean>;
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    itemTemplate?: React.ReactNode;
+    nodatamessage: string;
+    onItemClick: DefaultEventHandler;
+    onItemDoubleClick: DefaultEventHandler;
+    onItemMouseEnter: DefaultEventHandler;
+    onItemMouseLeave: DefaultEventHandler;
+    onHeaderClick: (groupKey: string) => void;
+    itemAttrs?: (item: ListItemData, index: number) => Record<string, unknown>;
+    hasListGroupAutoLayout?: boolean;
+    standalone?: boolean;
+}
+export interface UseCurrentPageItemsProps<T extends ListItemData = ListItemData> {
+    items: T[];
+    navigation: string;
+    currentPage: number;
+    pagesize: number;
+    visibleItems: number;
+    isServerPaginated?: boolean;
+}
+export interface CurrentPageItemsResult<T extends ListItemData = ListItemData> {
+    currentItems: T[];
+    startIndex: number;
+    endIndex: number;
+}
+export interface UsePaginatedGroupedDataProps<T extends ListItemData = ListItemData> {
+    groupedData: GroupedDataItem<T>[];
+    navigation: string;
+    currentPage: number;
+    pagesize: number;
+    visibleItems: number;
+    isServerSidePagination?: boolean;
+}
+export interface PaginatedGroupedDataItem<T extends ListItemData = ListItemData> extends GroupedDataItem<T> {
+    startIndexInGroup: number;
+}

package/components/data/list/components/props.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/components/data/list/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export { useListData } from "./useListData";
+export { useListState } from "./useListState";
+export { useGroupedData } from "./useGroupedData";
+export { useListEventHandlers } from "./useListEventHandlers";
+export { useListPagination } from "./useListPagination";
+export { useCurrentPageItems } from "./useCurrentPageItems";
+export { usePaginatedGroupedData } from "./usePaginatedGroupedData";
+export { useListEffects } from "./useListEffects";
+export { useDataSourceSubscription } from "../../../../hooks/useDataSourceSubscription";
+export { useListStateManager } from "./useListStateManager";
+export { type GroupedDataItem, type UseListDataProps, type ListEventHandlers, type ListPaginationState, type UseListEventHandlersProps, type UseListPaginationProps, } from "./props";

package/components/data/list/hooks/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useCurrentPageItems", {
+  enumerable: true,
+  get: function get() {
+    return _useCurrentPageItems.useCurrentPageItems;
+  }
+});
+Object.defineProperty(exports, "useDataSourceSubscription", {
+  enumerable: true,
+  get: function get() {
+    return _useDataSourceSubscription.useDataSourceSubscription;
+  }
+});
+Object.defineProperty(exports, "useGroupedData", {
+  enumerable: true,
+  get: function get() {
+    return _useGroupedData.useGroupedData;
+  }
+});
+Object.defineProperty(exports, "useListData", {
+  enumerable: true,
+  get: function get() {
+    return _useListData.useListData;
+  }
+});
+Object.defineProperty(exports, "useListEffects", {
+  enumerable: true,
+  get: function get() {
+    return _useListEffects.useListEffects;
+  }
+});
+Object.defineProperty(exports, "useListEventHandlers", {
+  enumerable: true,
+  get: function get() {
+    return _useListEventHandlers.useListEventHandlers;
+  }
+});
+Object.defineProperty(exports, "useListPagination", {
+  enumerable: true,
+  get: function get() {
+    return _useListPagination.useListPagination;
+  }
+});
+Object.defineProperty(exports, "useListState", {
+  enumerable: true,
+  get: function get() {
+    return _useListState.useListState;
+  }
+});
+Object.defineProperty(exports, "useListStateManager", {
+  enumerable: true,
+  get: function get() {
+    return _useListStateManager.useListStateManager;
+  }
+});
+Object.defineProperty(exports, "usePaginatedGroupedData", {
+  enumerable: true,
+  get: function get() {
+    return _usePaginatedGroupedData.usePaginatedGroupedData;
+  }
+});
+var _useListData = require("./useListData");
+var _useListState = require("./useListState");
+var _useGroupedData = require("./useGroupedData");
+var _useListEventHandlers = require("./useListEventHandlers");
+var _useListPagination = require("./useListPagination");
+var _useCurrentPageItems = require("./useCurrentPageItems");
+var _usePaginatedGroupedData = require("./usePaginatedGroupedData");
+var _useListEffects = require("./useListEffects");
+var _useDataSourceSubscription = require("../../../../hooks/useDataSourceSubscription");
+var _useListStateManager = require("./useListStateManager");

package/components/data/list/hooks/props.d.ts

@@ -0,0 +1,89 @@
+import React from "react";
+import { DefaultEventHandler, IPaginationMeta } from "../components/props";
+import { WmListProps, ListItemData, ListPaginationChangeHandler, ListSetRecordHandler, ListItemEventHandler, ListSelectHandler } from "../props";
+export interface GroupedDataItem<T = ListItemData> {
+    key: string;
+    data: T[];
+    originalDataLength?: number;
+    startIndexInGroup?: number;
+}
+export type UseListDataProps<T = ListItemData> = Pick<WmListProps<T>, "datafield" | "displayfield" | "displaylabel" | "getDisplayExpression" | "orderby" | "groupby">;
+export interface UseListEventHandlersProps<T extends ListItemData = ListItemData> {
+    items: T[];
+    multiselect: boolean;
+    disableitem: boolean;
+    selectionlimit: number;
+    collapsible: boolean;
+    selectedItems: T[];
+    setSelectedItems: (items: T[]) => void;
+    activeItems: Set<T>;
+    setActiveItems: (items: Set<T>) => void;
+    firstSelectedItem: T | null;
+    setFirstSelectedItem: (item: T | null) => void;
+    groupCollapsed: Record<string, boolean>;
+    setGroupCollapsed: (collapsed: Record<string, boolean>) => void;
+    currentPage: number;
+    setCurrentPage: (page: number) => void;
+    visibleItems: number;
+    setVisibleItems: (count: number) => void;
+    isLoadingMore: boolean;
+    setIsLoadingMore: (loading: boolean) => void;
+    onClick?: ListItemEventHandler;
+    onDblclick?: ListItemEventHandler;
+    onMouseEnter?: ListItemEventHandler;
+    onMouseLeave?: ListItemEventHandler;
+    onSelect?: ListSelectHandler<T>;
+    onSelectionlimitexceed?: (event: React.MouseEvent | null, widget: unknown) => void;
+    onPaginationchange?: (event: React.MouseEvent | null, widget: unknown, index: number) => void;
+    onPageChange?: (event: React.MouseEvent | null, page: number) => void;
+    onSetrecord?: (event: React.MouseEvent | null, widget: unknown, index: number, data: T) => void;
+    userInitiatedSelectionRef?: React.RefObject<boolean>;
+    datasource?: any;
+    pagesize?: number;
+    navigation?: string;
+    onDemandCurrentPage?: number;
+    setOnDemandCurrentPage?: (page: number) => void;
+    isServerSidePagination?: boolean;
+    name?: string;
+    listener?: any;
+    standalone?: boolean;
+}
+export interface ListEventHandlers<T extends ListItemData = ListItemData> {
+    handleListItemClick: DefaultEventHandler<T>;
+    handleListItemDoubleClick: DefaultEventHandler<T>;
+    handleListItemMouseEnter: DefaultEventHandler<T>;
+    handleListItemMouseLeave: DefaultEventHandler<T>;
+    handleHeaderClick: (groupKey: string) => void;
+    handlePaginationChange: ListPaginationChangeHandler;
+    handleSetRecord: ListSetRecordHandler<T>;
+    handlePageChange: (page: number) => void;
+    handleLoadMore: () => void;
+}
+export interface UseListPaginationProps<T extends ListItemData = ListItemData> {
+    items: T[];
+    groupedData?: GroupedDataItem<T>[];
+    groupby?: string;
+    pagesize: number;
+    allowpagesizechange: boolean;
+    pagesizeoptions: string;
+    navigation: string;
+    initialPage?: number;
+    datasource?: any;
+}
+export interface ListPaginationState<T extends ListItemData = ListItemData> {
+    currentPage: number;
+    setCurrentPage: (page: number) => void;
+    currentPageSize: number;
+    setCurrentPageSize: (size: number) => void;
+    totalPages: number;
+    visibleItems: number;
+    setVisibleItems: (count: number) => void;
+    currentPageItems: {
+        currentItems: T[];
+        startIndex: number;
+        endIndex: number;
+    };
+    effectiveTotalPages: number;
+    totalItems: number;
+    paginationMeta?: IPaginationMeta;
+}

package/components/data/list/hooks/props.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/components/data/list/hooks/useCurrentPageItems.d.ts

@@ -0,0 +1,6 @@
+import { ListItemData } from "../props";
+import { UseCurrentPageItemsProps, CurrentPageItemsResult } from "../components/props";
+/**
+ * Hook for calculating current page items based on navigation type and pagination
+ */
+export declare const useCurrentPageItems: <T extends ListItemData = ListItemData>({ items, navigation, currentPage, pagesize, visibleItems, isServerPaginated, }: UseCurrentPageItemsProps<T>) => CurrentPageItemsResult<T>;