@visa/nova-angular
Version:
Visa Product Design System Nova Angular library
204 lines • 36 kB
JavaScript
/**
* Copyright (c) 2025 Visa, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**/
/* eslint-disable no-mixed-spaces-and-tabs */
import { computed, signal } from '@angular/core';
/**
* Generates an array from number to from + length
* @param {number} from
* @param {number} length
* @returns {number[]}
*/
export const generateArray = (from, length) => Array.from({ length }, (_, i) => i + from);
const defaultOptions = {
blockMaxLength: 3,
compact: false,
defaultSelected: 1,
defaultTotalPages: 1,
delimiter: -1,
maxPageNumber: null,
startPage: 1
};
/**
* A signals based approach to handling and controlling pagination components. It is very customizable, re-usable, and even allows you to bring your own signal for selected page.
* @docs {@link https://design.visa.com/angular/components/pagination | See docs}
*/
export class PaginationControl {
constructor(options) {
this.totalPages = signal(0);
/// DERIVED STATE:
/** Can paginate or just show all pages */
this.canPaginate = computed(() => this.totalPages() > Math.max(this.options.endBlockMaxLength, this.options.startBlockMaxLength) + 2 && // 1 for end or start number + 1 for single separator show while in start/end blocks
this.totalPages() > this.options.middleBlockMaxLength + 4 // 2 for start and end numbers + 2 for separators shown while in middle block
);
/** Pages to show at the end */
this.endBlock = computed(() => this.isInEndBlock()
? generateArray(this.lastPage() - this.options.endBlockMaxLength + 1, this.options.endBlockMaxLength)
: [this.lastPage()]);
/** Ideal last page without maxPageNumber interfering */
this.idealLastPage = computed(() => this.totalPages() + this.options.startPage - 1);
/** Is first element selected */
this.isFirstPage = computed(() => this.selectedPage() === this.options.startPage);
/** Selected page is in end block */
this.isInEndBlock = computed(() => this.selectedPage() > this.lastPage() - this.options.endBlockMaxLength);
/** Selected page is in middle block */
this.isInMiddleBlock = computed(() => !this.isInStartBlock() && !this.isInEndBlock());
/** Selected page is in start block */
this.isInStartBlock = computed(() => this.selectedPage() < this.options.startPage + this.options.startBlockMaxLength);
/** Is last element selected */
this.isLastPage = computed(() => this.selectedPage() === this.lastPage());
/** Last page */
this.lastPage = computed(() => this.options.maxPageNumber === null
? this.idealLastPage()
: Math.min(this.options.maxPageNumber, this.idealLastPage()));
/** Pages to show in the middle */
this.middleBlock = computed(() => {
if (!this.isInMiddleBlock())
return [];
const middleBlockPadding = Math.floor(this.options.middleBlockMaxLength / 2);
if (this.selectedPage() - middleBlockPadding <= this.options.startPage)
return generateArray(this.selectedPage() - (this.selectedPage() - this.options.startPage) + 1, this.options.middleBlockMaxLength);
if (this.selectedPage() + middleBlockPadding >= this.lastPage())
return generateArray(this.selectedPage() + (this.lastPage() - this.selectedPage()) - this.options.middleBlockMaxLength, this.options.middleBlockMaxLength);
return generateArray(this.selectedPage() - middleBlockPadding, this.options.middleBlockMaxLength);
});
/** Array of pages arrays to loop over */
this.pages = computed(() => {
if (this.options.compact)
return this.compactPages;
return this.canPaginate()
? [this.startBlock(), this.middleBlock(), this.endBlock()]
.map((block) => (block.length ? [...block, this.options.delimiter] : []))
.flat()
.slice(0, -1)
: generateArray(this.options.startPage, this.lastPage() - this.options.startPage + 1);
});
/** Pages to show at the start */
this.startBlock = computed(() => this.isInStartBlock()
? generateArray(this.options.startPage, this.options.startBlockMaxLength)
: [this.options.startPage]);
/** Helper to calculate total pages */
this.getTotalPages = PaginationControl.getTotalPages;
const blockMaxLength = options?.blockMaxLength ?? defaultOptions.blockMaxLength;
// If we have a blockMaxLength, we should set it for all block max lengths, then we override it with all the options provided by the user
this.options = {
...defaultOptions,
endBlockMaxLength: blockMaxLength,
middleBlockMaxLength: blockMaxLength,
startBlockMaxLength: blockMaxLength,
...options
};
this.totalPages.set(this.options.defaultTotalPages);
const defaultStartPage = Math.min(Math.max(this.options.defaultSelected, this.options.startPage), this.options.defaultTotalPages);
this.selectedPage = this.options.selectedPage ?? signal(defaultStartPage);
this.selectedPage.set(defaultStartPage);
}
/// UTILITIES:
/** Getter for selectedPage, we shouldn't directly manipulate the `selectedPage` signal, use `goToPage` to do this safely */
get currentPage() {
return this.selectedPage();
}
get compactPages() {
const { blockMaxLength } = this.options;
// Show all pages if we have less than blockMaxLength
if (blockMaxLength > this.totalPages())
return generateArray(this.options.startPage, this.lastPage() - this.options.startPage + 1);
// Show chunk of blockMaxLength pages
const padding = Math.floor(blockMaxLength / 2);
if (this.selectedPage() - padding <= this.options.startPage)
return generateArray(this.options.startPage, blockMaxLength);
if (this.selectedPage() + padding >= this.lastPage())
return generateArray(this.lastPage() - blockMaxLength + 1, blockMaxLength);
return generateArray(this.selectedPage() - padding, blockMaxLength);
}
/**
* Calculates which range of items that is currently visible from pagination
* @param {number} items - how many items we have
* @param {number} itemsPerPage - how many items there are, per page
* @returns to from object with calculated values
*/
getToFrom(items, itemsPerPage) {
return PaginationControl.getToFrom(items, itemsPerPage, this.selectedPage(), this.options.startPage);
}
/** On first page event */
goToFirstPage() {
this.goToPage(this.options.startPage);
}
/** On last page event */
goToLastPage() {
this.goToPage(this.lastPage());
}
/** On next page event */
goToNextPage() {
this.goToPage(this.selectedPage() + 1);
}
/** On page change event */
goToPage(pageNumber) {
if (Number.isNaN(+pageNumber))
throw new Error("Can't go to page, invalid number");
if (pageNumber > this.lastPage())
this.selectedPage.set(this.lastPage());
else if (pageNumber < this.options.startPage)
this.selectedPage.set(this.options.startPage);
else
this.selectedPage.set(pageNumber);
}
/** On previous page event */
goToPreviousPage() {
this.goToPage(this.selectedPage() - 1);
}
/** Returns if page is current page */
isCurrentPage(page) {
return page === this.selectedPage();
}
/**
* In the context where total pages is calculated using items per page (much like tables use) we can use this utility to easily adjust the pagination control automatically.
* NOTE: by default this resets the pagination to the first page when called.
*/
resetPageCount(totalItems, itemsPerPage, autoResetToFirstPage = true) {
const totalPages = this.getTotalPages(totalItems, itemsPerPage);
this.totalPages.set(totalPages);
if (autoResetToFirstPage)
this.goToFirstPage();
}
/// STATIC UTILITIES:
/**
* Calculates which range of items that is currently visible from pagination
* @param {number} items - how many items we have
* @param {number} itemsPerPage - how many items there are, per page
* @param {number} currentPage - which page is visible
* @param {number} startPage - which page we're starting from, defaults to page 1 (optional)
* @returns to from object with calculated values
*/
static { this.getToFrom = (items, itemsPerPage, currentPage, startPage = 1) => {
if (itemsPerPage < 1 || items < 1)
return { 0: 0, 1: 0, from: 0, to: 0 };
const normalizedPageNumber = currentPage - startPage + 1;
const from = Math.max((normalizedPageNumber - 1) * itemsPerPage + 1, 0);
const to = Math.max(from + itemsPerPage - 1 > items ? items : from + itemsPerPage - 1, 0);
return { 0: from, 1: to, from, to };
}; }
/**
* Calculates how many pages there are
* @param {number} items - how many items we have
* @param {number} itemsPerPage - how many items there are, per page
* @returns {number} how many pages there are in total
*/
static getTotalPages(items, itemsPerPage) {
return Math.ceil(items / itemsPerPage);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.control.js","sourceRoot":"","sources":["../../../../../../libs/nova-lib/src/lib/pagination-control/pagination.control.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *              Copyright (c) 2025 Visa, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n **/\n/* eslint-disable no-mixed-spaces-and-tabs */\nimport { computed, Signal, signal, WritableSignal } from '@angular/core';\n\n/**\n * Generates an array from number to from + length\n * @param {number} from\n * @param {number} length\n * @returns {number[]}\n */\nexport const generateArray = (from: number, length: number): number[] => Array.from({ length }, (_, i) => i + from);\n\nexport type PaginationControlOptions = {\n  /** Max block length for all blocks, this gets overwritten by `startBlockMaxLength`, `middleBlockMaxLength`, `endBlockMaxLength` */\n  blockMaxLength: number;\n  /** Forces pages not to paginate */\n  compact: boolean;\n  /** Default selected page */\n  defaultSelected: number;\n  /** Default total amount of page */\n  defaultTotalPages: number;\n  /** What to separate the pagination array up with, usually this delimiter will be replaced with icon or ellipses when shown in the UI */\n  delimiter: number | string;\n  /** Maximum length of pages to show on the end pagination block, overwrites `blockMaxLength` for end block */\n  endBlockMaxLength: number;\n  /** Maximum page number to be shown, (default null for no maximum) */\n  maxPageNumber: number | null;\n  /** Maximum length of pages to show on the middle pagination block, overwrites `blockMaxLength` for middle block */\n  middleBlockMaxLength: number;\n  /** Signal to be used for selected page, otherwise control will create one */\n  selectedPage?: WritableSignal<number> | null;\n  /** Maximum length of pages to show on the start pagination block, overwrites `blockMaxLength` for start block */\n  startBlockMaxLength: number;\n  /** Start from this page */\n  startPage: number;\n};\n\nconst defaultOptions = {\n  blockMaxLength: 3,\n  compact: false,\n  defaultSelected: 1,\n  defaultTotalPages: 1,\n  delimiter: -1,\n  maxPageNumber: null,\n  startPage: 1\n} satisfies Partial<PaginationControlOptions>;\n\n/**\n * A signals based approach to handling and controlling pagination components. It is very customizable, re-usable, and even allows you to bring your own signal for selected page.\n * @docs {@link https://design.visa.com/angular/components/pagination | See docs}\n */\nexport class PaginationControl {\n  constructor(options?: Partial<PaginationControlOptions>) {\n    const blockMaxLength = options?.blockMaxLength ?? defaultOptions.blockMaxLength;\n    // If we have a blockMaxLength, we should set it for all block max lengths, then we override it with all the options provided by the user\n    this.options = {\n      ...defaultOptions,\n      endBlockMaxLength: blockMaxLength,\n      middleBlockMaxLength: blockMaxLength,\n      startBlockMaxLength: blockMaxLength,\n      ...options\n    } as PaginationControlOptions;\n    this.totalPages.set(this.options.defaultTotalPages);\n    const defaultStartPage = Math.min(\n      Math.max(this.options.defaultSelected, this.options.startPage),\n      this.options.defaultTotalPages\n    );\n    this.selectedPage = this.options.selectedPage ?? signal(defaultStartPage);\n    this.selectedPage.set(defaultStartPage);\n  }\n\n  /// STATE:\n\n  private readonly options: PaginationControlOptions;\n\n  private readonly selectedPage: WritableSignal<number>;\n\n  public readonly totalPages: WritableSignal<number> = signal<number>(0);\n\n  /// DERIVED STATE:\n\n  /** Can paginate or just show all pages */\n  private readonly canPaginate: Signal<boolean> = computed(\n    () =>\n      this.totalPages() > Math.max(this.options.endBlockMaxLength, this.options.startBlockMaxLength) + 2 && // 1 for end or start number + 1 for single separator show while in start/end blocks\n      this.totalPages() > this.options.middleBlockMaxLength + 4 // 2 for start and end numbers + 2 for separators shown while in middle block\n  );\n\n  /** Pages to show at the end */\n  private readonly endBlock: Signal<number[]> = computed(() =>\n    this.isInEndBlock()\n      ? generateArray(this.lastPage() - this.options.endBlockMaxLength + 1, this.options.endBlockMaxLength)\n      : [this.lastPage()]\n  );\n\n  /** Ideal last page without maxPageNumber interfering */\n  private readonly idealLastPage: Signal<number> = computed(() => this.totalPages() + this.options.startPage - 1);\n\n  /** Is first element selected */\n  public readonly isFirstPage: Signal<boolean> = computed(() => this.selectedPage() === this.options.startPage);\n\n  /** Selected page is in end block */\n  private readonly isInEndBlock: Signal<boolean> = computed(\n    () => this.selectedPage() > this.lastPage() - this.options.endBlockMaxLength\n  );\n\n  /** Selected page is in middle block */\n  private readonly isInMiddleBlock: Signal<boolean> = computed(() => !this.isInStartBlock() && !this.isInEndBlock());\n\n  /** Selected page is in start block */\n  private readonly isInStartBlock: Signal<boolean> = computed(\n    () => this.selectedPage() < this.options.startPage + this.options.startBlockMaxLength\n  );\n\n  /** Is last element selected */\n  public readonly isLastPage: Signal<boolean> = computed(() => this.selectedPage() === this.lastPage());\n\n  /** Last page */\n  private readonly lastPage: Signal<number> = computed(() =>\n    this.options.maxPageNumber === null\n      ? this.idealLastPage()\n      : Math.min(this.options.maxPageNumber, this.idealLastPage())\n  );\n\n  /** Pages to show in the middle */\n  private readonly middleBlock: Signal<number[]> = computed(() => {\n    if (!this.isInMiddleBlock()) return [];\n    const middleBlockPadding = Math.floor(this.options.middleBlockMaxLength / 2);\n    if (this.selectedPage() - middleBlockPadding <= this.options.startPage)\n      return generateArray(\n        this.selectedPage() - (this.selectedPage() - this.options.startPage) + 1,\n        this.options.middleBlockMaxLength\n      );\n    if (this.selectedPage() + middleBlockPadding >= this.lastPage())\n      return generateArray(\n        this.selectedPage() + (this.lastPage() - this.selectedPage()) - this.options.middleBlockMaxLength,\n        this.options.middleBlockMaxLength\n      );\n    return generateArray(this.selectedPage() - middleBlockPadding, this.options.middleBlockMaxLength);\n  });\n\n  /** Array of pages arrays to loop over */\n  public readonly pages: Signal<(string | number)[]> = computed(() => {\n    if (this.options.compact) return this.compactPages;\n    return this.canPaginate()\n      ? [this.startBlock(), this.middleBlock(), this.endBlock()]\n          .map((block) => (block.length ? [...block, this.options.delimiter] : []))\n          .flat()\n          .slice(0, -1)\n      : generateArray(this.options.startPage, this.lastPage() - this.options.startPage + 1);\n  });\n\n  /** Pages to show at the start */\n  private readonly startBlock: Signal<number[]> = computed(() =>\n    this.isInStartBlock()\n      ? generateArray(this.options.startPage, this.options.startBlockMaxLength)\n      : [this.options.startPage]\n  );\n\n  /// UTILITIES:\n\n  /** Getter for selectedPage, we shouldn't directly manipulate the `selectedPage` signal, use `goToPage` to do this safely */\n  public get currentPage(): number {\n    return this.selectedPage();\n  }\n\n  private get compactPages(): number[] {\n    const { blockMaxLength } = this.options;\n\n    // Show all pages if we have less than blockMaxLength\n    if (blockMaxLength > this.totalPages())\n      return generateArray(this.options.startPage, this.lastPage() - this.options.startPage + 1);\n\n    // Show chunk of blockMaxLength pages\n    const padding = Math.floor(blockMaxLength / 2);\n    if (this.selectedPage() - padding <= this.options.startPage)\n      return generateArray(this.options.startPage, blockMaxLength);\n    if (this.selectedPage() + padding >= this.lastPage())\n      return generateArray(this.lastPage() - blockMaxLength + 1, blockMaxLength);\n    return generateArray(this.selectedPage() - padding, blockMaxLength);\n  }\n\n  /**\n   * Calculates which range of items that is currently visible from pagination\n   * @param {number} items - how many items we have\n   * @param {number} itemsPerPage - how many items there are, per page\n   * @returns to from object with calculated values\n   */\n  public getToFrom(items: number, itemsPerPage: number) {\n    return PaginationControl.getToFrom(items, itemsPerPage, this.selectedPage(), this.options.startPage);\n  }\n\n  /** Helper to calculate total pages */\n  public getTotalPages = PaginationControl.getTotalPages;\n\n  /** On first page event */\n  public goToFirstPage(): void {\n    this.goToPage(this.options.startPage);\n  }\n\n  /** On last page event */\n  public goToLastPage(): void {\n    this.goToPage(this.lastPage());\n  }\n\n  /** On next page event */\n  public goToNextPage(): void {\n    this.goToPage(this.selectedPage() + 1);\n  }\n\n  /** On page change event */\n  public goToPage(pageNumber: number | string): void {\n    if (Number.isNaN(+pageNumber)) throw new Error(\"Can't go to page, invalid number\");\n    if ((pageNumber as number) > this.lastPage()) this.selectedPage.set(this.lastPage());\n    else if ((pageNumber as number) < this.options.startPage) this.selectedPage.set(this.options.startPage);\n    else this.selectedPage.set(pageNumber as number);\n  }\n\n  /** On previous page event */\n  public goToPreviousPage(): void {\n    this.goToPage(this.selectedPage() - 1);\n  }\n\n  /** Returns if page is current page */\n  public isCurrentPage(page: number | string): boolean {\n    return page === this.selectedPage();\n  }\n\n  /**\n   * In the context where total pages is calculated using items per page (much like tables use) we can use this utility to easily adjust the pagination control automatically.\n   * NOTE: by default this resets the pagination to the first page when called.\n   */\n  public resetPageCount(totalItems: number, itemsPerPage: number, autoResetToFirstPage = true): void {\n    const totalPages = this.getTotalPages(totalItems, itemsPerPage);\n    this.totalPages.set(totalPages);\n    if (autoResetToFirstPage) this.goToFirstPage();\n  }\n\n  /// STATIC UTILITIES:\n\n  /**\n   * Calculates which range of items that is currently visible from pagination\n   * @param {number} items - how many items we have\n   * @param {number} itemsPerPage - how many items there are, per page\n   * @param {number} currentPage - which page is visible\n   * @param {number} startPage - which page we're starting from, defaults to page 1 (optional)\n   * @returns to from object with calculated values\n   */\n  public static getToFrom = (items: number, itemsPerPage: number, currentPage: number, startPage: number = 1) => {\n    if (itemsPerPage < 1 || items < 1) return { 0: 0, 1: 0, from: 0, to: 0 };\n    const normalizedPageNumber = currentPage - startPage + 1;\n    const from = Math.max((normalizedPageNumber - 1) * itemsPerPage + 1, 0);\n    const to = Math.max(from + itemsPerPage - 1 > items ? items : from + itemsPerPage - 1, 0);\n    return { 0: from, 1: to, from, to };\n  };\n\n  /**\n   * Calculates how many pages there are\n   * @param {number} items - how many items we have\n   * @param {number} itemsPerPage - how many items there are, per page\n   * @returns {number} how many pages there are in total\n   */\n  public static getTotalPages(items: number, itemsPerPage: number): number {\n    return Math.ceil(items / itemsPerPage);\n  }\n}\n"]}