@1money/component-ui 0.0.1

package/es/components/Pagination/interface.d.ts

@@ -0,0 +1,54 @@
+import type { HTMLAttributes } from 'react';
+export type PaginationItemType = 'previous' | 'page' | 'ellipsis' | 'next';
+export type PaginationEllipsisPosition = 'start' | 'end';
+export interface UsePaginationOptions {
+    total: number;
+    pageSize?: number;
+    current?: number;
+    defaultCurrent?: number;
+    disabled?: boolean;
+    /**
+     * Number of pages always displayed at both the start and end of the pagination.
+     */
+    boundaryCount?: number;
+    /**
+     * Maximum number of pages displayed in the current-page window.
+     */
+    middlePageCount?: number;
+    onChange?: (page: number, pageSize: number) => void;
+}
+export interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'>, UsePaginationOptions {
+    prefixCls?: string;
+    'aria-label'?: string;
+}
+export interface PaginationItemBase {
+    key: string;
+    type: PaginationItemType;
+    disabled?: boolean;
+}
+export interface PaginationPageItem extends PaginationItemBase {
+    type: 'page';
+    page: number;
+    current: boolean;
+}
+export interface PaginationControlItem extends PaginationItemBase {
+    type: 'previous' | 'next';
+    page: number;
+}
+export interface PaginationEllipsisItem extends PaginationItemBase {
+    type: 'ellipsis';
+    position: PaginationEllipsisPosition;
+}
+export type PaginationItem = PaginationPageItem | PaginationControlItem | PaginationEllipsisItem;
+export interface UsePaginationResult {
+    current: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+    canPrevious: boolean;
+    canNext: boolean;
+    items: PaginationItem[];
+    goTo: (page: number) => void;
+    previous: () => void;
+    next: () => void;
+}

package/es/components/Pagination/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9QYWdpbmF0aW9uL2ludGVyZmFjZS5qcyIsIm5hbWVzIjpbXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9QYWdpbmF0aW9uL2ludGVyZmFjZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge307Il0sIm1hcHBpbmdzIjoiQUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/es/components/Pagination/style/Pagination.css

@@ -0,0 +1 @@
+.om-react-ui-pagination,.om-react-ui-pagination-list{display:inline-flex;align-items:center}.om-react-ui-pagination-list{gap:var(--om-spacing-200,8px);margin:0;padding:0;list-style:none}.om-react-ui-pagination-item{display:inline-flex;flex-shrink:0;align-items:center}.om-react-ui-pagination-button,.om-react-ui-pagination-ellipsis{display:inline-flex;align-items:center;justify-content:center;min-height:calc(var(--om-spacing-400, 16px) + var(--om-spacing-500, 20px));padding:var(--om-spacing-200,8px) var(--om-spacing-300,12px);color:var(--om-text-default,#131313);white-space:nowrap;background-color:transparent;border:none;border-radius:var(--om-radius-200,8px);font-variant-numeric:tabular-nums}.om-react-ui-pagination-button{gap:var(--om-spacing-200,8px);cursor:pointer}.om-react-ui-pagination-button:hover:not(:disabled){background-color:var(--om-bg-default-hover,#f0f0f0)}.om-react-ui-pagination-button:focus-visible{outline:none;box-shadow:0 0 0 2px var(--om-border-brand,#073387)}.om-react-ui-pagination-button-page{min-width:max(calc(var(--om-spacing-400, 16px) + var(--om-spacing-500, 20px)),2ch + var(--om-spacing-300,12px) + var(--om-spacing-300,12px))}.om-react-ui-pagination-button-current{color:var(--om-text-on-neutral,#fff);background-color:var(--om-bg-brand,#073387)}.om-react-ui-pagination-button-current:hover:not(:disabled){background-color:var(--om-bg-brand-hover,#052561)}.om-react-ui-pagination-button-disabled{color:var(--om-text-disabled,#bbbdc1);cursor:not-allowed}.om-react-ui-pagination-button-disabled:hover{background-color:transparent}.om-react-ui-pagination-icon{display:inline-flex;flex-shrink:0;align-items:center;justify-content:center}.om-react-ui-pagination-ellipsis{padding-right:var(--om-spacing-400,16px);padding-left:var(--om-spacing-400,16px);cursor:default}.om-react-ui-pagination-disabled{cursor:not-allowed}

package/es/components/Pagination/style/Pagination.scss

@@ -0,0 +1,95 @@
+@use '@/styles/api' as theme;
+
+$component: 'pagination';
+$pagination-control-size: calc(#{theme.spacing(scale, 400)} + #{theme.spacing(scale, 500)});
+
+.#{theme.$prefix}-#{$component} {
+  display: inline-flex;
+  align-items: center;
+
+  &-list {
+    display: inline-flex;
+    gap: theme.spacing(gap, 200);
+    align-items: center;
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  &-item {
+    display: inline-flex;
+    flex-shrink: 0;
+    align-items: center;
+  }
+
+  &-button,
+  &-ellipsis {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: $pagination-control-size;
+    padding: theme.spacing(component-padding, 200) theme.spacing(component-padding, 300);
+    color: theme.palette(text, 'default');
+    white-space: nowrap;
+    background-color: transparent;
+    border: none;
+    border-radius: theme.shape(200);
+    font-variant-numeric: tabular-nums;
+  }
+
+  &-button {
+    gap: theme.spacing(gap, 200);
+    cursor: pointer;
+
+    &:hover:not(:disabled) {
+      background-color: theme.palette(bg, 'default-hover');
+    }
+
+    &:focus-visible {
+      outline: none;
+      box-shadow: 0 0 0 2px theme.palette(border, 'brand');
+    }
+  }
+
+  &-button-page {
+    min-width: max(
+      #{$pagination-control-size},
+      calc(2ch + #{theme.spacing(component-padding, 300)} + #{theme.spacing(component-padding, 300)})
+    );
+  }
+
+  &-button-current {
+    color: theme.palette(text, 'on-neutral');
+    background-color: theme.palette(bg, 'brand');
+
+    &:hover:not(:disabled) {
+      background-color: theme.palette(bg, 'brand-hover');
+    }
+  }
+
+  &-button-disabled {
+    color: theme.palette(text, 'disabled');
+    cursor: not-allowed;
+
+    &:hover {
+      background-color: transparent;
+    }
+  }
+
+  &-icon {
+    display: inline-flex;
+    flex-shrink: 0;
+    align-items: center;
+    justify-content: center;
+  }
+
+  &-ellipsis {
+    padding-right: theme.spacing(component-padding, 400);
+    padding-left: theme.spacing(component-padding, 400);
+    cursor: default;
+  }
+
+  &-disabled {
+    cursor: not-allowed;
+  }
+}

package/es/components/Pagination/style/css.js

@@ -0,0 +1,2 @@
+import './Pagination.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUGFnaW5hdGlvbi9zcmMvY29tcG9uZW50cy9QYWdpbmF0aW9uL3N0eWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sbUJBQW1CIiwiZmlsZSI6ImNvbXBvbmVudHMvUGFnaW5hdGlvbi9zdHlsZS9jc3MuanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Pagination/style/index.d.ts

@@ -0,0 +1 @@
+import './Pagination.scss';

package/es/components/Pagination/style/index.js

@@ -0,0 +1,2 @@
+import './Pagination.scss';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUGFnaW5hdGlvbi9zcmMvY29tcG9uZW50cy9QYWdpbmF0aW9uL3N0eWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sbUJBQW1CIiwiZmlsZSI6ImNvbXBvbmVudHMvUGFnaW5hdGlvbi9zdHlsZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/components/Pagination/usePagination.d.ts

@@ -0,0 +1,3 @@
+import type { UsePaginationOptions, UsePaginationResult } from './interface';
+export declare const usePagination: (options: UsePaginationOptions) => UsePaginationResult;
+export default usePagination;

package/es/components/Pagination/usePagination.js

@@ -0,0 +1,154 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { useMemo } from 'react';
+import { useControlledState, useEventCallback } from '@1money/hooks';
+import { PAGINATION_DEFAULT_BOUNDARY_COUNT, PAGINATION_DEFAULT_CURRENT, PAGINATION_DEFAULT_MIDDLE_PAGE_COUNT, PAGINATION_DEFAULT_PAGE_SIZE, PAGINATION_DEFAULT_TOTAL, PAGINATION_ELLIPSIS_POSITION, PAGINATION_GAP_FILL_THRESHOLD, PAGINATION_ITEM_TYPE, PAGINATION_KEY_PREFIX } from './constants';
+var toInteger = function toInteger(value, fallback) {
+  var parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : fallback;
+};
+var clamp = function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+};
+var normalizeTotal = function normalizeTotal(total) {
+  return Math.max(PAGINATION_DEFAULT_TOTAL, toInteger(total, PAGINATION_DEFAULT_TOTAL));
+};
+var normalizePageSize = function normalizePageSize(pageSize) {
+  return Math.max(PAGINATION_DEFAULT_CURRENT, toInteger(pageSize, PAGINATION_DEFAULT_PAGE_SIZE));
+};
+var normalizeBoundaryCount = function normalizeBoundaryCount(boundaryCount) {
+  return Math.max(PAGINATION_DEFAULT_TOTAL, toInteger(boundaryCount, PAGINATION_DEFAULT_BOUNDARY_COUNT));
+};
+var normalizeMiddlePageCount = function normalizeMiddlePageCount(middlePageCount) {
+  return Math.max(PAGINATION_DEFAULT_CURRENT, toInteger(middlePageCount, PAGINATION_DEFAULT_MIDDLE_PAGE_COUNT));
+};
+var getTotalPages = function getTotalPages(total, pageSize) {
+  return Math.max(PAGINATION_DEFAULT_CURRENT, Math.ceil(total / pageSize));
+};
+var getVisiblePages = function getVisiblePages(current, totalPages, boundaryCount, middlePageCount) {
+  var pages = new Set();
+  var maxWindowStart = Math.max(PAGINATION_DEFAULT_CURRENT, totalPages - middlePageCount + PAGINATION_DEFAULT_CURRENT);
+  var windowStart = clamp(current - Math.floor((middlePageCount - PAGINATION_DEFAULT_CURRENT) / 2), PAGINATION_DEFAULT_CURRENT, maxWindowStart);
+  var windowEnd = Math.min(windowStart + middlePageCount - PAGINATION_DEFAULT_CURRENT, totalPages);
+  for (var page = PAGINATION_DEFAULT_CURRENT; page <= Math.min(boundaryCount, totalPages); page += 1) {
+    pages.add(page);
+  }
+  for (var _page = Math.max(totalPages - boundaryCount + PAGINATION_DEFAULT_CURRENT, PAGINATION_DEFAULT_CURRENT); _page <= totalPages; _page += 1) {
+    pages.add(_page);
+  }
+  for (var _page2 = windowStart; _page2 <= windowEnd; _page2 += 1) {
+    pages.add(_page2);
+  }
+  return _toConsumableArray(pages).filter(function (page) {
+    return page >= PAGINATION_DEFAULT_CURRENT && page <= totalPages;
+  }).sort(function (left, right) {
+    return left - right;
+  });
+};
+var createPageItem = function createPageItem(page, current, disabled) {
+  return {
+    key: "".concat(PAGINATION_KEY_PREFIX.page, "-").concat(page),
+    type: PAGINATION_ITEM_TYPE.page,
+    page: page,
+    current: page === current,
+    disabled: disabled
+  };
+};
+var createControlItem = function createControlItem(type, page, disabled) {
+  return {
+    key: type,
+    type: type,
+    page: page,
+    disabled: disabled
+  };
+};
+var createEllipsisItem = function createEllipsisItem(position) {
+  return {
+    key: "".concat(PAGINATION_KEY_PREFIX.ellipsis, "-").concat(position),
+    type: PAGINATION_ITEM_TYPE.ellipsis,
+    position: position,
+    disabled: true
+  };
+};
+var buildPageItems = function buildPageItems(current, totalPages, disabled, boundaryCount, middlePageCount) {
+  var visiblePages = getVisiblePages(current, totalPages, boundaryCount, middlePageCount);
+  var items = [];
+  var previousPage = 0;
+  var ellipsisCount = 0;
+  visiblePages.forEach(function (page) {
+    if (previousPage > 0) {
+      var gap = page - previousPage;
+      if (gap === PAGINATION_GAP_FILL_THRESHOLD) {
+        items.push(createPageItem(previousPage + 1, current, disabled));
+      } else if (gap > PAGINATION_GAP_FILL_THRESHOLD) {
+        ellipsisCount += 1;
+        items.push(createEllipsisItem(ellipsisCount === 1 ? PAGINATION_ELLIPSIS_POSITION.start : PAGINATION_ELLIPSIS_POSITION.end));
+      }
+    }
+    items.push(createPageItem(page, current, disabled));
+    previousPage = page;
+  });
+  return items;
+};
+var buildPaginationItems = function buildPaginationItems(current, totalPages, disabled, boundaryCount, middlePageCount) {
+  var canPrevious = current > PAGINATION_DEFAULT_CURRENT;
+  var canNext = current < totalPages;
+  return [createControlItem(PAGINATION_ITEM_TYPE.previous, clamp(current - 1, PAGINATION_DEFAULT_CURRENT, totalPages), disabled || !canPrevious)].concat(_toConsumableArray(buildPageItems(current, totalPages, disabled, boundaryCount, middlePageCount)), [createControlItem(PAGINATION_ITEM_TYPE.next, clamp(current + 1, PAGINATION_DEFAULT_CURRENT, totalPages), disabled || !canNext)]);
+};
+export var usePagination = function usePagination(options) {
+  var total = options.total,
+    pageSize = options.pageSize,
+    current = options.current,
+    _options$defaultCurre = options.defaultCurrent,
+    defaultCurrent = _options$defaultCurre === void 0 ? PAGINATION_DEFAULT_CURRENT : _options$defaultCurre,
+    _options$disabled = options.disabled,
+    disabled = _options$disabled === void 0 ? false : _options$disabled,
+    boundaryCount = options.boundaryCount,
+    middlePageCount = options.middlePageCount,
+    onChange = options.onChange;
+  var resolvedTotal = normalizeTotal(total);
+  var resolvedPageSize = normalizePageSize(pageSize);
+  var resolvedBoundaryCount = normalizeBoundaryCount(boundaryCount);
+  var resolvedMiddlePageCount = normalizeMiddlePageCount(middlePageCount);
+  var totalPages = getTotalPages(resolvedTotal, resolvedPageSize);
+  var controlledCurrent = current === undefined ? undefined : clamp(toInteger(current, PAGINATION_DEFAULT_CURRENT), PAGINATION_DEFAULT_CURRENT, totalPages);
+  var _useControlledState = useControlledState(clamp(toInteger(defaultCurrent, PAGINATION_DEFAULT_CURRENT), PAGINATION_DEFAULT_CURRENT, totalPages), controlledCurrent),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    innerCurrent = _useControlledState2[0],
+    setInnerCurrent = _useControlledState2[1];
+  var resolvedCurrent = clamp(toInteger(innerCurrent, PAGINATION_DEFAULT_CURRENT), PAGINATION_DEFAULT_CURRENT, totalPages);
+  var goTo = useEventCallback(function (page) {
+    if (disabled) {
+      return;
+    }
+    var nextPage = clamp(toInteger(page, resolvedCurrent), PAGINATION_DEFAULT_CURRENT, totalPages);
+    if (nextPage === resolvedCurrent) {
+      return;
+    }
+    setInnerCurrent(nextPage);
+    onChange === null || onChange === void 0 ? void 0 : onChange(nextPage, resolvedPageSize);
+  });
+  var previous = useEventCallback(function () {
+    goTo(resolvedCurrent - 1);
+  });
+  var next = useEventCallback(function () {
+    goTo(resolvedCurrent + 1);
+  });
+  var items = useMemo(function () {
+    return buildPaginationItems(resolvedCurrent, totalPages, disabled, resolvedBoundaryCount, resolvedMiddlePageCount);
+  }, [resolvedCurrent, totalPages, disabled, resolvedBoundaryCount, resolvedMiddlePageCount]);
+  return {
+    current: resolvedCurrent,
+    pageSize: resolvedPageSize,
+    total: resolvedTotal,
+    totalPages: totalPages,
+    canPrevious: resolvedCurrent > PAGINATION_DEFAULT_CURRENT,
+    canNext: resolvedCurrent < totalPages,
+    items: items,
+    goTo: goTo,
+    previous: previous,
+    next: next
+  };
+};
+export default usePagination;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/Pagination/usePagination.ts","components/Pagination/usePagination.js"],"names":["useMemo","useControlledState","useEventCallback","PAGINATION_DEFAULT_BOUNDARY_COUNT","PAGINATION_DEFAULT_CURRENT","PAGINATION_DEFAULT_MIDDLE_PAGE_COUNT","PAGINATION_DEFAULT_PAGE_SIZE","PAGINATION_DEFAULT_TOTAL","PAGINATION_ELLIPSIS_POSITION","PAGINATION_GAP_FILL_THRESHOLD","PAGINATION_ITEM_TYPE","PAGINATION_KEY_PREFIX","toInteger","value","fallback","parsed","Number","isFinite","Math","trunc","clamp","min","max","normalizeTotal","total","normalizePageSize","pageSize","normalizeBoundaryCount","boundaryCount","normalizeMiddlePageCount","middlePageCount","getTotalPages","ceil","getVisiblePages","current","totalPages","pages","Set","maxWindowStart","windowStart","floor","windowEnd","page","add","_toConsumableArray","filter","sort","left","right","createPageItem","disabled","key","concat","type","createControlItem","createEllipsisItem","position","ellipsis","buildPageItems","visiblePages","items","previousPage","ellipsisCount","forEach","gap","push","start","end","buildPaginationItems","canPrevious","canNext","previous","next","usePagination","options","_options$defaultCurre","defaultCurrent","_options$disabled","onChange","resolvedTotal","resolvedPageSize","resolvedBoundaryCount","resolvedMiddlePageCount","controlledCurrent","undefined","_useControlledState","_useControlledState2","_slicedToArray","innerCurrent","setInnerCurrent","resolvedCurrent","goTo","nextPage"],"mappings":"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","file":"components/Pagination/usePagination.js","sourcesContent":[null,"import { useMemo } from 'react';\nimport { useControlledState, useEventCallback } from '@1money/hooks';\nimport { PAGINATION_DEFAULT_BOUNDARY_COUNT, PAGINATION_DEFAULT_CURRENT, PAGINATION_DEFAULT_MIDDLE_PAGE_COUNT, PAGINATION_DEFAULT_PAGE_SIZE, PAGINATION_DEFAULT_TOTAL, PAGINATION_ELLIPSIS_POSITION, PAGINATION_GAP_FILL_THRESHOLD, PAGINATION_ITEM_TYPE, PAGINATION_KEY_PREFIX, } from './constants';\nconst toInteger = (value, fallback) => {\n    const parsed = Number(value);\n    return Number.isFinite(parsed) ? Math.trunc(parsed) : fallback;\n};\nconst clamp = (value, min, max) => Math.min(Math.max(value, min), max);\nconst normalizeTotal = (total) => Math.max(PAGINATION_DEFAULT_TOTAL, toInteger(total, PAGINATION_DEFAULT_TOTAL));\nconst normalizePageSize = (pageSize) => Math.max(PAGINATION_DEFAULT_CURRENT, toInteger(pageSize, PAGINATION_DEFAULT_PAGE_SIZE));\nconst normalizeBoundaryCount = (boundaryCount) => Math.max(PAGINATION_DEFAULT_TOTAL, toInteger(boundaryCount, PAGINATION_DEFAULT_BOUNDARY_COUNT));\nconst normalizeMiddlePageCount = (middlePageCount) => Math.max(PAGINATION_DEFAULT_CURRENT, toInteger(middlePageCount, PAGINATION_DEFAULT_MIDDLE_PAGE_COUNT));\nconst getTotalPages = (total, pageSize) => Math.max(PAGINATION_DEFAULT_CURRENT, Math.ceil(total / pageSize));\nconst getVisiblePages = (current, totalPages, boundaryCount, middlePageCount) => {\n    const pages = new Set();\n    const maxWindowStart = Math.max(PAGINATION_DEFAULT_CURRENT, totalPages - middlePageCount + PAGINATION_DEFAULT_CURRENT);\n    const windowStart = clamp(current - Math.floor((middlePageCount - PAGINATION_DEFAULT_CURRENT) / 2), PAGINATION_DEFAULT_CURRENT, maxWindowStart);\n    const windowEnd = Math.min(windowStart + middlePageCount - PAGINATION_DEFAULT_CURRENT, totalPages);\n    for (let page = PAGINATION_DEFAULT_CURRENT; page <= Math.min(boundaryCount, totalPages); page += 1) {\n        pages.add(page);\n    }\n    for (let page = Math.max(totalPages - boundaryCount + PAGINATION_DEFAULT_CURRENT, PAGINATION_DEFAULT_CURRENT); page <= totalPages; page += 1) {\n        pages.add(page);\n    }\n    for (let page = windowStart; page <= windowEnd; page += 1) {\n        pages.add(page);\n    }\n    return [...pages]\n        .filter(page => page >= PAGINATION_DEFAULT_CURRENT && page <= totalPages)\n        .sort((left, right) => left - right);\n};\nconst createPageItem = (page, current, disabled) => ({\n    key: `${PAGINATION_KEY_PREFIX.page}-${page}`,\n    type: PAGINATION_ITEM_TYPE.page,\n    page,\n    current: page === current,\n    disabled,\n});\nconst createControlItem = (type, page, disabled) => ({\n    key: type,\n    type,\n    page,\n    disabled,\n});\nconst createEllipsisItem = (position) => ({\n    key: `${PAGINATION_KEY_PREFIX.ellipsis}-${position}`,\n    type: PAGINATION_ITEM_TYPE.ellipsis,\n    position,\n    disabled: true,\n});\nconst buildPageItems = (current, totalPages, disabled, boundaryCount, middlePageCount) => {\n    const visiblePages = getVisiblePages(current, totalPages, boundaryCount, middlePageCount);\n    const items = [];\n    let previousPage = 0;\n    let ellipsisCount = 0;\n    visiblePages.forEach(page => {\n        if (previousPage > 0) {\n            const gap = page - previousPage;\n            if (gap === PAGINATION_GAP_FILL_THRESHOLD) {\n                items.push(createPageItem(previousPage + 1, current, disabled));\n            }\n            else if (gap > PAGINATION_GAP_FILL_THRESHOLD) {\n                ellipsisCount += 1;\n                items.push(createEllipsisItem(ellipsisCount === 1\n                    ? PAGINATION_ELLIPSIS_POSITION.start\n                    : PAGINATION_ELLIPSIS_POSITION.end));\n            }\n        }\n        items.push(createPageItem(page, current, disabled));\n        previousPage = page;\n    });\n    return items;\n};\nconst buildPaginationItems = (current, totalPages, disabled, boundaryCount, middlePageCount) => {\n    const canPrevious = current > PAGINATION_DEFAULT_CURRENT;\n    const canNext = current < totalPages;\n    return [\n        createControlItem(PAGINATION_ITEM_TYPE.previous, clamp(current - 1, PAGINATION_DEFAULT_CURRENT, totalPages), disabled || !canPrevious),\n        ...buildPageItems(current, totalPages, disabled, boundaryCount, middlePageCount),\n        createControlItem(PAGINATION_ITEM_TYPE.next, clamp(current + 1, PAGINATION_DEFAULT_CURRENT, totalPages), disabled || !canNext),\n    ];\n};\nexport const usePagination = (options) => {\n    const { total, pageSize, current, defaultCurrent = PAGINATION_DEFAULT_CURRENT, disabled = false, boundaryCount, middlePageCount, onChange, } = options;\n    const resolvedTotal = normalizeTotal(total);\n    const resolvedPageSize = normalizePageSize(pageSize);\n    const resolvedBoundaryCount = normalizeBoundaryCount(boundaryCount);\n    const resolvedMiddlePageCount = normalizeMiddlePageCount(middlePageCount);\n    const totalPages = getTotalPages(resolvedTotal, resolvedPageSize);\n    const controlledCurrent = current === undefined\n        ? undefined\n        : clamp(toInteger(current, PAGINATION_DEFAULT_CURRENT), PAGINATION_DEFAULT_CURRENT, totalPages);\n    const [innerCurrent, setInnerCurrent] = useControlledState(clamp(toInteger(defaultCurrent, PAGINATION_DEFAULT_CURRENT), PAGINATION_DEFAULT_CURRENT, totalPages), controlledCurrent);\n    const resolvedCurrent = clamp(toInteger(innerCurrent, PAGINATION_DEFAULT_CURRENT), PAGINATION_DEFAULT_CURRENT, totalPages);\n    const goTo = useEventCallback((page) => {\n        if (disabled) {\n            return;\n        }\n        const nextPage = clamp(toInteger(page, resolvedCurrent), PAGINATION_DEFAULT_CURRENT, totalPages);\n        if (nextPage === resolvedCurrent) {\n            return;\n        }\n        setInnerCurrent(nextPage);\n        onChange === null || onChange === void 0 ? void 0 : onChange(nextPage, resolvedPageSize);\n    });\n    const previous = useEventCallback(() => {\n        goTo(resolvedCurrent - 1);\n    });\n    const next = useEventCallback(() => {\n        goTo(resolvedCurrent + 1);\n    });\n    const items = useMemo(() => buildPaginationItems(resolvedCurrent, totalPages, disabled, resolvedBoundaryCount, resolvedMiddlePageCount), [resolvedCurrent, totalPages, disabled, resolvedBoundaryCount, resolvedMiddlePageCount]);\n    return {\n        current: resolvedCurrent,\n        pageSize: resolvedPageSize,\n        total: resolvedTotal,\n        totalPages,\n        canPrevious: resolvedCurrent > PAGINATION_DEFAULT_CURRENT,\n        canNext: resolvedCurrent < totalPages,\n        items,\n        goTo,\n        previous,\n        next,\n    };\n};\nexport default usePagination;"],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Popconfirm/Popconfirm.d.ts

@@ -0,0 +1,6 @@
+import type { FC } from 'react';
+import type { PopconfirmProps } from './interface';
+import './style';
+export declare const Popconfirm: FC<PopconfirmProps>;
+declare const _default: import("react").NamedExoticComponent<PopconfirmProps>;
+export default _default;

package/es/components/Popconfirm/Popconfirm.js

@@ -0,0 +1,131 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from 'react';
+import { useEventCallback } from '@1money/hooks';
+import { Button } from '../Button';
+import { Icons } from '../Icons';
+import Trigger from '../Trigger';
+import { default as classnames, joinCls } from '../../utils/classnames';
+import './style';
+import { POPCONFIRM_ACTION_BUTTON_DEFAULTS, POPCONFIRM_ACTION_KIND, POPCONFIRM_DEFAULT_CANCEL_TEXT, POPCONFIRM_DEFAULT_CONFIRM_TEXT, POPCONFIRM_DEFAULT_ICON, POPCONFIRM_DEFAULT_OFFSET, POPCONFIRM_DEFAULT_PLACEMENT, POPCONFIRM_DEFAULT_PREFIX, POPCONFIRM_DEFAULT_TRIGGER, POPCONFIRM_ICON_SIZE, POPCONFIRM_ROLE, POPCONFIRM_SLOT } from './constants';
+export var Popconfirm = function Popconfirm(props) {
+  var children = props.children,
+    _props$className = props.className,
+    className = _props$className === void 0 ? '' : _props$className,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? POPCONFIRM_DEFAULT_PREFIX : _props$prefixCls,
+    title = props.title,
+    body = props.body,
+    _props$icon = props.icon,
+    icon = _props$icon === void 0 ? POPCONFIRM_DEFAULT_ICON : _props$icon,
+    _props$showIcon = props.showIcon,
+    showIcon = _props$showIcon === void 0 ? true : _props$showIcon,
+    _props$showArrow = props.showArrow,
+    showArrow = _props$showArrow === void 0 ? true : _props$showArrow,
+    _props$cancelText = props.cancelText,
+    cancelText = _props$cancelText === void 0 ? POPCONFIRM_DEFAULT_CANCEL_TEXT : _props$cancelText,
+    _props$confirmText = props.confirmText,
+    confirmText = _props$confirmText === void 0 ? POPCONFIRM_DEFAULT_CONFIRM_TEXT : _props$confirmText,
+    cancelButtonProps = props.cancelButtonProps,
+    confirmButtonProps = props.confirmButtonProps,
+    _props$closeOnCancel = props.closeOnCancel,
+    closeOnCancel = _props$closeOnCancel === void 0 ? true : _props$closeOnCancel,
+    _props$closeOnConfirm = props.closeOnConfirm,
+    closeOnConfirm = _props$closeOnConfirm === void 0 ? true : _props$closeOnConfirm,
+    onCancel = props.onCancel,
+    onConfirm = props.onConfirm,
+    _props$trigger = props.trigger,
+    trigger = _props$trigger === void 0 ? POPCONFIRM_DEFAULT_TRIGGER : _props$trigger,
+    _props$placement = props.placement,
+    placement = _props$placement === void 0 ? POPCONFIRM_DEFAULT_PLACEMENT : _props$placement,
+    _props$offset = props.offset,
+    offset = _props$offset === void 0 ? POPCONFIRM_DEFAULT_OFFSET : _props$offset,
+    overlayClassName = props.overlayClassName,
+    overlayStyle = props.overlayStyle,
+    rest = __rest(props, ["children", "className", "prefixCls", "title", "body", "icon", "showIcon", "showArrow", "cancelText", "confirmText", "cancelButtonProps", "confirmButtonProps", "closeOnCancel", "closeOnConfirm", "onCancel", "onConfirm", "trigger", "placement", "offset", "overlayClassName", "overlayStyle"]);
+  var classes = classnames(prefixCls);
+  var actions = [{
+    kind: POPCONFIRM_ACTION_KIND.cancel,
+    label: cancelText,
+    buttonProps: cancelButtonProps,
+    callback: onCancel,
+    shouldClose: closeOnCancel
+  }, {
+    kind: POPCONFIRM_ACTION_KIND.confirm,
+    label: confirmText,
+    buttonProps: confirmButtonProps,
+    callback: onConfirm,
+    shouldClose: closeOnConfirm
+  }];
+  var handleAction = useEventCallback(function (event, context, callback, buttonHandler, shouldClose) {
+    buttonHandler === null || buttonHandler === void 0 ? void 0 : buttonHandler(event);
+    callback === null || callback === void 0 ? void 0 : callback(event, context);
+    if (shouldClose && !event.defaultPrevented) {
+      context.close();
+    }
+  });
+  return _jsx(Trigger, Object.assign({}, rest, {
+    trigger: trigger,
+    placement: placement,
+    offset: offset,
+    role: POPCONFIRM_ROLE,
+    showArrow: false,
+    overlayClassName: joinCls(classes(POPCONFIRM_SLOT.overlay), overlayClassName),
+    overlayStyle: overlayStyle,
+    content: function content(_ref) {
+      var close = _ref.close,
+        open = _ref.open;
+      var actionContext = {
+        close: close,
+        open: open
+      };
+      return _jsxs("div", {
+        className: classes(undefined, joinCls(!showArrow && classes(POPCONFIRM_SLOT.noArrow), className)),
+        children: [(showIcon || title || body) && _jsxs("div", {
+          className: classes(POPCONFIRM_SLOT.header),
+          children: [showIcon && _jsx("span", {
+            className: classes(POPCONFIRM_SLOT.icon),
+            children: _jsx(Icons, {
+              name: icon,
+              size: POPCONFIRM_ICON_SIZE
+            })
+          }), _jsxs("div", {
+            className: classes(POPCONFIRM_SLOT.content),
+            children: [title && _jsx("div", {
+              className: classes(POPCONFIRM_SLOT.title),
+              children: title
+            }), body && _jsx("div", {
+              className: classes(POPCONFIRM_SLOT.body),
+              children: body
+            })]
+          })]
+        }), _jsx("div", {
+          className: classes(POPCONFIRM_SLOT.actions),
+          children: actions.map(function (_ref2) {
+            var kind = _ref2.kind,
+              label = _ref2.label,
+              buttonProps = _ref2.buttonProps,
+              callback = _ref2.callback,
+              shouldClose = _ref2.shouldClose;
+            return _jsx(Button, Object.assign({}, POPCONFIRM_ACTION_BUTTON_DEFAULTS[kind], buttonProps, {
+              onClick: function onClick(event) {
+                handleAction(event, actionContext, callback, buttonProps === null || buttonProps === void 0 ? void 0 : buttonProps.onClick, shouldClose);
+              },
+              children: label
+            }), kind);
+          })
+        })]
+      });
+    },
+    children: children
+  }));
+};
+export default /*#__PURE__*/memo(Popconfirm);
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Popconfirm/Popconfirm.js","components/src/components/Popconfirm/Popconfirm.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","memo","useEventCallback","Button","Icons","Trigger","default","classnames","joinCls","POPCONFIRM_ACTION_BUTTON_DEFAULTS","POPCONFIRM_ACTION_KIND","POPCONFIRM_DEFAULT_CANCEL_TEXT","POPCONFIRM_DEFAULT_CONFIRM_TEXT","POPCONFIRM_DEFAULT_ICON","POPCONFIRM_DEFAULT_OFFSET","POPCONFIRM_DEFAULT_PLACEMENT","POPCONFIRM_DEFAULT_PREFIX","POPCONFIRM_DEFAULT_TRIGGER","POPCONFIRM_ICON_SIZE","POPCONFIRM_ROLE","POPCONFIRM_SLOT","Popconfirm","props","children","_props$className","className","_props$prefixCls","prefixCls","title","body","_props$icon","icon","_props$showIcon","showIcon","_props$showArrow","showArrow","_props$cancelText","cancelText","_props$confirmText","confirmText","cancelButtonProps","confirmButtonProps","_props$closeOnCancel","closeOnCancel","_props$closeOnConfirm","closeOnConfirm","onCancel","onConfirm","_props$trigger","trigger","_props$placement","placement","_props$offset","offset","overlayClassName","overlayStyle","rest","classes","actions","kind","cancel","label","buttonProps","callback","shouldClose","confirm","handleAction","event","context","buttonHandler","defaultPrevented","close","assign","role","overlay","content","_ref","open","actionContext","undefined","noArrow","header","name","size","map","_ref2","onClick"],"mappings":"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","file":"components/Popconfirm/Popconfirm.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { useEventCallback } from '@1money/hooks';\nimport { Button } from '../Button';\nimport { Icons } from '../Icons';\nimport Trigger from '../Trigger';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nimport './style';\nimport { POPCONFIRM_ACTION_BUTTON_DEFAULTS, POPCONFIRM_ACTION_KIND, POPCONFIRM_DEFAULT_CANCEL_TEXT, POPCONFIRM_DEFAULT_CONFIRM_TEXT, POPCONFIRM_DEFAULT_ICON, POPCONFIRM_DEFAULT_OFFSET, POPCONFIRM_DEFAULT_PLACEMENT, POPCONFIRM_DEFAULT_PREFIX, POPCONFIRM_DEFAULT_TRIGGER, POPCONFIRM_ICON_SIZE, POPCONFIRM_ROLE, POPCONFIRM_SLOT, } from './constants';\nexport const Popconfirm = (props) => {\n    const { children, className = '', prefixCls = POPCONFIRM_DEFAULT_PREFIX, title, body, icon = POPCONFIRM_DEFAULT_ICON, showIcon = true, showArrow = true, cancelText = POPCONFIRM_DEFAULT_CANCEL_TEXT, confirmText = POPCONFIRM_DEFAULT_CONFIRM_TEXT, cancelButtonProps, confirmButtonProps, closeOnCancel = true, closeOnConfirm = true, onCancel, onConfirm, trigger = POPCONFIRM_DEFAULT_TRIGGER, placement = POPCONFIRM_DEFAULT_PLACEMENT, offset = POPCONFIRM_DEFAULT_OFFSET, overlayClassName, overlayStyle } = props, rest = __rest(props, [\"children\", \"className\", \"prefixCls\", \"title\", \"body\", \"icon\", \"showIcon\", \"showArrow\", \"cancelText\", \"confirmText\", \"cancelButtonProps\", \"confirmButtonProps\", \"closeOnCancel\", \"closeOnConfirm\", \"onCancel\", \"onConfirm\", \"trigger\", \"placement\", \"offset\", \"overlayClassName\", \"overlayStyle\"]);\n    const classes = classnames(prefixCls);\n    const actions = [\n        {\n            kind: POPCONFIRM_ACTION_KIND.cancel,\n            label: cancelText,\n            buttonProps: cancelButtonProps,\n            callback: onCancel,\n            shouldClose: closeOnCancel,\n        },\n        {\n            kind: POPCONFIRM_ACTION_KIND.confirm,\n            label: confirmText,\n            buttonProps: confirmButtonProps,\n            callback: onConfirm,\n            shouldClose: closeOnConfirm,\n        },\n    ];\n    const handleAction = useEventCallback((event, context, callback, buttonHandler, shouldClose) => {\n        buttonHandler === null || buttonHandler === void 0 ? void 0 : buttonHandler(event);\n        callback === null || callback === void 0 ? void 0 : callback(event, context);\n        if (shouldClose && !event.defaultPrevented) {\n            context.close();\n        }\n    });\n    return (_jsx(Trigger, Object.assign({}, rest, { trigger: trigger, placement: placement, offset: offset, role: POPCONFIRM_ROLE, showArrow: false, overlayClassName: joinCls(classes(POPCONFIRM_SLOT.overlay), overlayClassName), overlayStyle: overlayStyle, content: ({ close, open }) => {\n            const actionContext = { close, open };\n            return (_jsxs(\"div\", { className: classes(undefined, joinCls(!showArrow && classes(POPCONFIRM_SLOT.noArrow), className)), children: [(showIcon || title || body) && (_jsxs(\"div\", { className: classes(POPCONFIRM_SLOT.header), children: [showIcon && (_jsx(\"span\", { className: classes(POPCONFIRM_SLOT.icon), children: _jsx(Icons, { name: icon, size: POPCONFIRM_ICON_SIZE }) })), _jsxs(\"div\", { className: classes(POPCONFIRM_SLOT.content), children: [title && _jsx(\"div\", { className: classes(POPCONFIRM_SLOT.title), children: title }), body && _jsx(\"div\", { className: classes(POPCONFIRM_SLOT.body), children: body })] })] })), _jsx(\"div\", { className: classes(POPCONFIRM_SLOT.actions), children: actions.map(({ kind, label, buttonProps, callback, shouldClose }) => (_jsx(Button, Object.assign({}, POPCONFIRM_ACTION_BUTTON_DEFAULTS[kind], buttonProps, { onClick: (event) => {\n                                handleAction(event, actionContext, callback, buttonProps === null || buttonProps === void 0 ? void 0 : buttonProps.onClick, shouldClose);\n                            }, children: label }), kind))) })] }));\n        }, children: children })));\n};\nexport default memo(Popconfirm);",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Popconfirm/constants.d.ts

@@ -0,0 +1,72 @@
+import type { Placement } from '@floating-ui/react';
+import type { ButtonProps } from "../Button";
+import type { IconName } from "../Icons";
+import type { TriggerAction, TriggerProps } from "../Trigger/interface";
+export declare const POPCONFIRM_DEFAULT_PREFIX = "popconfirm";
+export declare const POPCONFIRM_DEFAULT_ICON: IconName;
+export declare const POPCONFIRM_DEFAULT_CANCEL_TEXT = "Cancel";
+export declare const POPCONFIRM_DEFAULT_CONFIRM_TEXT = "Confirm";
+export declare const POPCONFIRM_DEFAULT_TRIGGER: TriggerAction;
+export declare const POPCONFIRM_DEFAULT_PLACEMENT: Placement;
+export declare const POPCONFIRM_DEFAULT_OFFSET = 8;
+export declare const POPCONFIRM_ROLE: NonNullable<TriggerProps['role']>;
+export declare const POPCONFIRM_ICON_SIZE = 32;
+export declare const POPCONFIRM_ACTION_KIND: {
+    readonly cancel: "cancel";
+    readonly confirm: "confirm";
+};
+export declare const POPCONFIRM_SLOT: {
+    readonly overlay: "overlay";
+    readonly noArrow: "no-arrow";
+    readonly header: "header";
+    readonly icon: "icon";
+    readonly content: "content";
+    readonly title: "title";
+    readonly body: "body";
+    readonly actions: "actions";
+};
+export declare const POPCONFIRM_TRIGGER_OPTIONS: TriggerAction[];
+export declare const POPCONFIRM_PLACEMENTS: Placement[];
+export declare const POPCONFIRM_ICON_OPTIONS: IconName[];
+export declare const POPCONFIRM_DEMO_COPY: {
+    readonly destructive: {
+        readonly title: "Delete transfer rule?";
+        readonly body: "This action removes the rule immediately and cannot be undone.";
+        readonly cancelText: "Keep rule";
+        readonly confirmText: "Delete";
+        readonly triggerText: "Delete rule";
+    };
+    readonly archive: {
+        readonly title: "Archive this wallet?";
+        readonly body: "Archiving keeps history intact, but the wallet will disappear from active lists.";
+        readonly cancelText: "Cancel";
+        readonly confirmText: "Archive";
+        readonly triggerText: "Archive wallet";
+    };
+    readonly placementBody: "Popover alignment and beak placement should follow the trigger.";
+    readonly controlledTriggerText: "Controlled Popconfirm";
+    readonly toggleText: "Toggle";
+    readonly openStateText: "Open";
+    readonly closedStateText: "Closed";
+};
+export declare const POPCONFIRM_STORY_STYLE: {
+    readonly placementsWrapper: {
+        display: "flex";
+        flexWrap: "wrap";
+        gap: number;
+        padding: number;
+        justifyContent: "center";
+    };
+    readonly controlledWrapper: {
+        display: "flex";
+        gap: number;
+        alignItems: "center";
+    };
+};
+interface PopconfirmActionButtonDefaults {
+    color: NonNullable<ButtonProps['color']>;
+    size: NonNullable<ButtonProps['size']>;
+}
+export type PopconfirmActionKind = (typeof POPCONFIRM_ACTION_KIND)[keyof typeof POPCONFIRM_ACTION_KIND];
+export declare const POPCONFIRM_ACTION_BUTTON_DEFAULTS: Record<PopconfirmActionKind, PopconfirmActionButtonDefaults>;
+export {};