@firestitch/list 15.0.0 → 16.0.0

package/esm2022/app/classes/pagination-controller.mjs

@@ -0,0 +1,491 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { distinctUntilChanged, takeUntil } from 'rxjs/operators';
+import { PageChangeType } from '../enums/page-change-type.enum';
+import { PaginationStrategy } from '../enums/pagination-strategy.enum';
+export class PaginationController {
+    limit = 25;
+    records;
+    manual = false;
+    page = 1; // Active page
+    offset = 0;
+    displayed = 0;
+    _pages$ = new BehaviorSubject(0); // Total pages
+    _strategy = PaginationStrategy.None;
+    _removedRows = 0;
+    _pageChanged$ = new Subject();
+    _pageReset$ = new Subject();
+    _onDestroy$ = new Subject();
+    _loadMoreConfig;
+    _limits = [10, 25, 50, 100, 200];
+    // Total pages
+    set pages(value) {
+        this._pages$.next(value);
+    }
+    get pages() {
+        return this._pages$.getValue();
+    }
+    get pages$() {
+        return this._pages$
+            .pipe(distinctUntilChanged());
+    }
+    /**
+     * Fire if page was changed
+     */
+    get pageChanged$() {
+        return this._pageChanged$.pipe(takeUntil(this._onDestroy$));
+    }
+    get pageReset$() {
+        return this._pageReset$.asObservable();
+    }
+    /**
+     * Get enabled
+     */
+    get enabled() {
+        return !this.hasNoneStrategy;
+    }
+    /**
+     * Get Limits
+     */
+    get limits() {
+        return this._limits;
+    }
+    /**
+     * Set limits, update pages array and set new limit per page
+     *
+     * @param value
+     */
+    set limits(value) {
+        this._limits = value;
+        if (this.limits.length > 0 && this.limits.indexOf(this.limit) === -1) {
+            this.limit = this.limits[0];
+        }
+        else if (this.limits.length === 0) {
+            this.limit = this.records;
+        }
+    }
+    /**
+     * Get query for request
+     */
+    get query() {
+        switch (this.strategy) {
+            case PaginationStrategy.Page:
+                return this.queryPageStrategy;
+            case PaginationStrategy.Offset:
+                return this.queryOffsetStrategy;
+        }
+        return {};
+    }
+    get loadMoreQuery() {
+        switch (this.strategy) {
+            case PaginationStrategy.Page: {
+                return this.query;
+            }
+            case PaginationStrategy.Offset: {
+                const query = this.queryOffsetStrategy;
+                query.limit = query.offset + query.limit;
+                query.offset = 0;
+                return query;
+            }
+        }
+        return {};
+    }
+    /**
+     * Query for Page Strategy
+     */
+    get queryPageStrategy() {
+        return this.hasNoneStrategy
+            ? {}
+            : {
+                page: this.page || 1,
+                limit: this.limit || 10,
+            };
+    }
+    /**
+     * Query for Offset Strategy
+     */
+    get queryOffsetStrategy() {
+        const page = this.page - 1 || 0;
+        const limit = this.limit || 5;
+        return {
+            offset: page * limit,
+            limit,
+        };
+    }
+    /**
+     * Get query for load only count of deleted rows
+     */
+    get loadDeletedOffsetQuery() {
+        const paginationOffset = this.limit * this.page;
+        const actualOffset = Math.min(this.records, paginationOffset);
+        const offset = Math.max(0, actualOffset - this._removedRows);
+        return {
+            offset,
+            limit: this._removedRows,
+        };
+    }
+    get initialized() {
+        return !!this.pages;
+    }
+    get strategy() {
+        return this._strategy;
+    }
+    set strategy(strategy) {
+        this._strategy = (strategy === undefined) ? PaginationStrategy.Page : strategy;
+    }
+    /**
+     * Check if pagination in Page Strategy Mode
+     */
+    get hasPageStrategy() {
+        return this.strategy === PaginationStrategy.Page;
+    }
+    /**
+     * Check if pagination in Offset Strategy Mode
+     */
+    get hasOffsetStrategy() {
+        return this.strategy === PaginationStrategy.Offset;
+    }
+    /**
+     * Check if pagination in None Strategy Mode
+     */
+    get hasNoneStrategy() {
+        return this.strategy === PaginationStrategy.None;
+    }
+    /**
+     * If prev page can be activated
+     *
+     */
+    get hasPrevPage() {
+        switch (this.strategy) {
+            case PaginationStrategy.Page:
+                return this._hasPrevPagePageStrategy;
+            case PaginationStrategy.Offset:
+                return this._hasPrevPageOffsetStrategy;
+        }
+        return false;
+    }
+    /**
+     * If next page can be activated
+     */
+    get hasNextPage() {
+        switch (this.strategy) {
+            case PaginationStrategy.Page:
+                return this._hasNextPagePageStrategy;
+            case PaginationStrategy.Offset:
+                return this._hasNextPageOffsetStrategy;
+        }
+        return false;
+    }
+    get loadMoreEnabled() {
+        return this._loadMoreConfig.enabled;
+    }
+    get loadMoreLabel() {
+        return this._loadMoreConfig.label;
+    }
+    get loadMoreButtonColor() {
+        return this._loadMoreConfig.buttonColor;
+    }
+    get loadMoreButtonClass() {
+        if (this._loadMoreConfig.buttonType === 'basic') {
+            return '';
+        }
+        return `mat-${this._loadMoreConfig.buttonType}-button`;
+    }
+    get loadMoreButtonType() {
+        return this._loadMoreConfig.buttonType;
+    }
+    /**
+     * SP-T1974
+     * Showing 26-50 of 333 results sorted by Name, Ascending
+     * Showing 0 results sorted by Name, Ascending
+     */
+    get statusLabel() {
+        const current = (this.page - 1) * this.limit;
+        const from = current + 1;
+        const to = Math.min(this.records, current + this.limit);
+        return `${from}-${to}`;
+    }
+    get state() {
+        return {
+            enabled: this.enabled,
+            strategy: this.strategy,
+            page: this.page,
+            offset: this.offset,
+            limit: this.limit,
+            records: this.records,
+            displayed: this.displayed,
+        };
+    }
+    initWithConfig(config, loadMore) {
+        if (config) {
+            if (config.limits) {
+                this.limits = config.limits;
+            }
+            if (config.limit) {
+                this.limit = config.limit;
+            }
+            this.strategy = config.strategy;
+        }
+        this.setLoadMore(loadMore);
+    }
+    /**
+     * If pagination has prev page when Page Strategy
+     */
+    get _hasPrevPagePageStrategy() {
+        return this.page > 1 && this.pages > 1;
+    }
+    /**
+     * If pagination has prev page when Offset Strategy
+     */
+    get _hasPrevPageOffsetStrategy() {
+        return this.offset >= this.limit && this.records > 1;
+    }
+    /**
+     * If pagination has next page when Page Strategy
+     */
+    get _hasNextPagePageStrategy() {
+        return this.page < this.pages && this.pages > 1;
+    }
+    /**
+     * If pagination has next page when Offset Strategy
+     */
+    get _hasNextPageOffsetStrategy() {
+        return (this.offset + this.limit) < this.records && this.records > 1;
+    }
+    /**
+     * Update paging config and all related fields
+     *
+     * @param config
+     * @param displayedRecords
+     * @param loadMoreOperation
+     */
+    updatePaging(config, displayedRecords = 0, loadMoreOperation = false) {
+        if (!loadMoreOperation) {
+            this._fromParams(config);
+            this.displayed = displayedRecords;
+        }
+        else {
+            this.records = config.records;
+            if (this.records < this.displayed) {
+                this.displayed = this.records;
+            }
+            this._removedRows = 0;
+        }
+        this._updateTotalPages();
+    }
+    // /**
+    //  * Update paging when data source not remove
+    //  * @param {any[]} rows
+    //  */
+    /*public updatePagingManual(rows: any[]) {
+      if (Array.isArray(rows) && rows.length > 0) {
+        this.records = rows.length;
+        this.pages = Math.ceil(rows.length / this.limit);
+      }
+  
+      this.updatePagesArray();
+      this.updateDisplayed();
+    }*/
+    /**
+     * Update pages array with new pages count
+     */
+    // public updatePagesArray() {
+    //   const MIDDLE = 2;
+    //   const pagesArr = [];
+    //   let from = 0;
+    //   let to = 0;
+    //   if (this.page < MIDDLE) {
+    //     from = MIDDLE - 1;
+    //     to = MIDDLE + 1;
+    //   } else if (this.page >= MIDDLE && this.page <= this.pages - MIDDLE + 1) {
+    //     from = this.page - 1;
+    //     to = this.page + 1;
+    //   } else if (this.page > this.pages - MIDDLE + 1) {
+    //     from = this.pages - MIDDLE - 1;
+    //     to = this.pages;
+    //   }
+    //   if (!this.pages || this.pages < 5) {
+    //     from = 1;
+    //     to = this.pages || 0;
+    //   }
+    //   for (let i = from; i <= to; i++) {
+    //     pagesArr.push(i);
+    //   }
+    //   this.pagesArray = Object.assign([], pagesArr);
+    // }
+    setLoadMore(config) {
+        const loadMoreConfig = typeof config === 'boolean' ?
+            {
+                enabled: !!config,
+            } :
+            (config === undefined ? {} : {
+                ...config,
+                enabled: true,
+            });
+        this._loadMoreConfig = {
+            enabled: false,
+            label: 'Load More',
+            buttonType: 'basic',
+            ...loadMoreConfig,
+        };
+    }
+    /**
+     * Update dispayed records counter
+     */
+    // public updateDisplayed() {
+    //   this.displayed = this.getVisibleRecords();
+    // }
+    /**
+     * Return count of records that could be shown on page
+     */
+    // public getVisibleRecords() {
+    //   const diff = this.hasOffsetStrategy
+    //     ? this.records - this.offset
+    //     : this.limit;
+    //
+    //   return diff < this.limit
+    //     ? diff
+    //     : this.displayed;
+    // }
+    getVisibleRecords() {
+        return this.displayed;
+    }
+    /**
+     * Set new limit
+     *
+     * @param limit
+     */
+    setLimit(limit) {
+        this.limit = limit;
+        this.resetPaging();
+        this._pageChanged$.next({
+            type: PageChangeType.LimitChanged,
+            payload: limit,
+        });
+    }
+    /**
+     * If page is activate page
+     *
+     * @param page
+     */
+    isActive(page) {
+        return page === this.page;
+    }
+    /**
+     * Go to page
+     *
+     * @param page
+     */
+    goToPage(page) {
+        if (page >= 1 && this.page !== page) {
+            this.page = page;
+            this._updateOffset();
+            this._pageChanged$.next({
+                type: PageChangeType.Default,
+                payload: page,
+            });
+        }
+    }
+    /**
+     * Reset paging like it was just initialized
+     */
+    resetPaging() {
+        this.page = 1;
+        this.offset = 0;
+    }
+    /**
+     * Go to next page
+     */
+    goNext() {
+        if (this.hasNextPage) {
+            this.page++;
+            this._updateOffset();
+            this._pageChanged$.next({
+                type: PageChangeType.Default,
+                payload: this.page,
+            });
+        }
+    }
+    /**
+     * Go to first page
+     */
+    goFirst() {
+        if (this.page > 1) {
+            this.page = 1;
+            this._updateOffset();
+            this._pageChanged$.next({
+                type: PageChangeType.Default,
+                payload: this.page,
+            });
+        }
+    }
+    /**
+     * Go to prev page
+     */
+    goPrev() {
+        if (this.page > 1) {
+            this.page--;
+            this._updateOffset();
+            this._pageChanged$.next({
+                type: PageChangeType.Default,
+                payload: this.page,
+            });
+        }
+    }
+    /**
+     * Go to last page
+     */
+    goLast() {
+        if (this.page !== this.pages) {
+            this.page = this.pages;
+            this._updateOffset();
+            this._pageChanged$.next({
+                type: PageChangeType.Default,
+                payload: this.page,
+            });
+        }
+    }
+    /**
+     * Update count of deleted rows. This count will be applied for offset calc
+     *
+     * @param count
+     */
+    removeRows(count) {
+        this._removedRows += count;
+    }
+    updatePagination() {
+        this._updateTotalPages();
+    }
+    /**
+     * Destroy
+     */
+    destroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+    }
+    /**
+     * Update paging state
+     *
+     * @param params
+     */
+    _fromParams(params) {
+        if (!this.loadMoreEnabled) {
+            this.limit = params.limit ?? 25;
+        }
+        this.records = params.records;
+        this.manual = params.manual;
+        this.pages = params.pages || 0;
+    }
+    /**
+     * Calc and update offset
+     */
+    _updateOffset() {
+        this.offset = this.limit * (this.page - 1);
+    }
+    /**
+     * Calc and update total count of pages
+     */
+    _updateTotalPages() {
+        this.pages = Math.ceil(this.records / this.limit);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination-controller.js","sourceRoot":"","sources":["../../../../src/app/classes/pagination-controller.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, takeUntil } from 'rxjs/operators';\n\n\nimport { PageChangeType } from '../enums/page-change-type.enum';\nimport { PaginationStrategy } from '../enums/pagination-strategy.enum';\nimport {\n  FsListLoadMoreConfig,\n  FsPaging,\n  PageChange,\n  QueryOffsetStrategy,\n  QueryPageStrategy,\n} from '../interfaces';\nimport { IPaginationState } from '../interfaces/pagination-state.interface';\n\nexport class PaginationController {\n\n  public limit = 25;\n  public records: number;\n  public manual = false;\n\n  public page = 1; // Active page\n  public offset = 0;\n\n  public displayed = 0;\n\n  private _pages$ = new BehaviorSubject<number>(0); // Total pages\n\n  private _strategy: PaginationStrategy = PaginationStrategy.None;\n  private _removedRows = 0;\n\n  private _pageChanged$ = new Subject<PageChange>();\n  private _pageReset$ = new Subject<void>();\n  private _onDestroy$ = new Subject();\n\n  private _loadMoreConfig: FsListLoadMoreConfig;\n  private _limits = [10, 25, 50, 100, 200];\n\n  // Total pages\n  public set pages(value: number) {\n    this._pages$.next(value);\n  }\n\n  public get pages(): number {\n    return this._pages$.getValue();\n  }\n\n  public get pages$(): Observable<number> {\n    return this._pages$\n      .pipe(\n        distinctUntilChanged(),\n      );\n  }\n\n  /**\n   * Fire if page was changed\n   */\n  public get pageChanged$(): Observable<PageChange> {\n    return this._pageChanged$.pipe(takeUntil(this._onDestroy$));\n  }\n\n  public get pageReset$(): Observable<void> {\n    return this._pageReset$.asObservable();\n  }\n\n  /**\n   * Get enabled\n   */\n  public get enabled(): boolean {\n    return !this.hasNoneStrategy;\n  }\n\n  /**\n   * Get Limits\n   */\n  public get limits(): number[] {\n    return this._limits;\n  }\n\n  /**\n   * Set limits, update pages array and set new limit per page\n   *\n   * @param value\n   */\n  public set limits(value) {\n    this._limits = value;\n\n    if (this.limits.length > 0 && this.limits.indexOf(this.limit) === -1) {\n      this.limit = this.limits[0];\n    } else if (this.limits.length === 0) {\n      this.limit = this.records;\n    }\n  }\n\n  /**\n   * Get query for request\n   */\n  public get query() {\n    switch (this.strategy) {\n      case PaginationStrategy.Page:\n        return this.queryPageStrategy;\n      case PaginationStrategy.Offset:\n        return this.queryOffsetStrategy;\n    }\n\n    return {};\n  }\n\n  public get loadMoreQuery() {\n    switch (this.strategy) {\n      case PaginationStrategy.Page: {\n        return this.query;\n      }\n\n      case PaginationStrategy.Offset: {\n        const query = this.queryOffsetStrategy;\n\n        query.limit = query.offset + query.limit;\n        query.offset = 0;\n\n        return query;\n      }\n    }\n\n    return {};\n  }\n\n  /**\n   * Query for Page Strategy\n   */\n  public get queryPageStrategy(): QueryPageStrategy {\n    return this.hasNoneStrategy\n      ? {}\n      : {\n        page: this.page || 1,\n        limit: this.limit || 10,\n      };\n  }\n\n  /**\n   * Query for Offset Strategy\n   */\n  public get queryOffsetStrategy(): QueryOffsetStrategy {\n    const page = this.page - 1 || 0;\n    const limit = this.limit || 5;\n\n    return {\n      offset: page * limit,\n      limit,\n    };\n  }\n\n  /**\n   * Get query for load only count of deleted rows\n   */\n  public get loadDeletedOffsetQuery() {\n    const paginationOffset = this.limit * this.page;\n    const actualOffset = Math.min(this.records, paginationOffset);\n    const offset = Math.max(0, actualOffset - this._removedRows);\n\n    return {\n      offset,\n      limit: this._removedRows,\n    };\n  }\n\n  public get initialized() {\n    return !!this.pages;\n  }\n\n  public get strategy() {\n    return this._strategy;\n  }\n\n  public set strategy(strategy: PaginationStrategy) {\n    this._strategy = (strategy === undefined) ? PaginationStrategy.Page : strategy;\n  }\n\n  /**\n   * Check if pagination in Page Strategy Mode\n   */\n  public get hasPageStrategy() {\n    return this.strategy === PaginationStrategy.Page;\n  }\n\n  /**\n   * Check if pagination in Offset Strategy Mode\n   */\n  public get hasOffsetStrategy() {\n    return this.strategy === PaginationStrategy.Offset;\n  }\n\n  /**\n   * Check if pagination in None Strategy Mode\n   */\n  public get hasNoneStrategy(): boolean {\n    return this.strategy === PaginationStrategy.None;\n  }\n\n  /**\n   * If prev page can be activated\n   *\n   */\n  public  get hasPrevPage(): boolean {\n    switch (this.strategy) {\n      case PaginationStrategy.Page:\n        return this._hasPrevPagePageStrategy;\n      case PaginationStrategy.Offset:\n        return this._hasPrevPageOffsetStrategy;\n    }\n\n    return false;\n  }\n\n  /**\n   * If next page can be activated\n   */\n  public get hasNextPage(): boolean { // Need to check if pages === page && page === 1\n    switch (this.strategy) {\n      case PaginationStrategy.Page:\n        return this._hasNextPagePageStrategy;\n      case PaginationStrategy.Offset:\n        return this._hasNextPageOffsetStrategy;\n    }\n\n    return false;\n  }\n\n  public get loadMoreEnabled(): boolean {\n    return this._loadMoreConfig.enabled;\n  }\n\n  public get loadMoreLabel(): string {\n    return this._loadMoreConfig.label;\n  }\n\n  public get loadMoreButtonColor(): string {\n    return this._loadMoreConfig.buttonColor;\n  }\n\n  public get loadMoreButtonClass(): string {\n    if( this._loadMoreConfig.buttonType === 'basic' ) {\n      return ''; \n    }\n\n    return `mat-${this._loadMoreConfig.buttonType}-button`;\n  }\n\n  public get loadMoreButtonType(): string {\n    return this._loadMoreConfig.buttonType;\n  }\n\n  /**\n   * SP-T1974\n   * Showing 26-50 of 333 results sorted by Name, Ascending\n   * Showing 0 results sorted by Name, Ascending\n   */\n  public get statusLabel(): string {\n    const current = (this.page - 1) * this.limit;\n    const from = current + 1;\n    const to = Math.min(this.records, current + this.limit);\n\n    return `${from}-${to}`;\n  }\n\n  public get state(): IPaginationState {\n    return {\n      enabled: this.enabled,\n      strategy: this.strategy,\n      page: this.page,\n      offset: this.offset,\n      limit: this.limit,\n      records: this.records,\n      displayed: this.displayed,\n    };\n  }\n\n  public initWithConfig(\n    config: FsPaging | false,\n    loadMore: FsListLoadMoreConfig | boolean,\n  ) {\n\n    if (config) {\n      if (config.limits) {\n        this.limits = config.limits;\n      }\n\n      if (config.limit) {\n        this.limit = config.limit;\n      }\n\n      this.strategy = config.strategy;\n    }\n    \n    this.setLoadMore(loadMore);\n  }\n\n  /**\n   * If pagination has prev page when Page Strategy\n   */\n  private get _hasPrevPagePageStrategy(): boolean {\n    return this.page > 1 && this.pages > 1;\n  }\n\n  /**\n   * If pagination has prev page when Offset Strategy\n   */\n  private get _hasPrevPageOffsetStrategy(): boolean {\n    return this.offset >= this.limit && this.records > 1;\n  }\n\n  /**\n   * If pagination has next page when Page Strategy\n   */\n  private get _hasNextPagePageStrategy(): boolean {\n    return this.page < this.pages && this.pages > 1;\n  }\n\n  /**\n   * If pagination has next page when Offset Strategy\n   */\n  private get _hasNextPageOffsetStrategy(): boolean {\n    return (this.offset + this.limit) < this.records && this.records > 1;\n  }\n\n  /**\n   * Update paging config and all related fields\n   *\n   * @param config\n   * @param displayedRecords\n   * @param loadMoreOperation\n   */\n  public updatePaging(config, displayedRecords = 0, loadMoreOperation = false) {\n    if (!loadMoreOperation) {\n      this._fromParams(config);\n      this.displayed = displayedRecords;\n    } else {\n      this.records = config.records;\n\n      if (this.records < this.displayed) {\n        this.displayed = this.records;\n      }\n\n      this._removedRows = 0;\n    }\n\n    this._updateTotalPages();\n  }\n\n  // /**\n  //  * Update paging when data source not remove\n  //  * @param {any[]} rows\n  //  */\n  /*public updatePagingManual(rows: any[]) {\n    if (Array.isArray(rows) && rows.length > 0) {\n      this.records = rows.length;\n      this.pages = Math.ceil(rows.length / this.limit);\n    }\n\n    this.updatePagesArray();\n    this.updateDisplayed();\n  }*/\n\n  /**\n   * Update pages array with new pages count\n   */\n  // public updatePagesArray() {\n  //   const MIDDLE = 2;\n  //   const pagesArr = [];\n\n  //   let from = 0;\n  //   let to = 0;\n  //   if (this.page < MIDDLE) {\n  //     from = MIDDLE - 1;\n  //     to = MIDDLE + 1;\n  //   } else if (this.page >= MIDDLE && this.page <= this.pages - MIDDLE + 1) {\n  //     from = this.page - 1;\n  //     to = this.page + 1;\n  //   } else if (this.page > this.pages - MIDDLE + 1) {\n  //     from = this.pages - MIDDLE - 1;\n  //     to = this.pages;\n  //   }\n\n  //   if (!this.pages || this.pages < 5) {\n  //     from = 1;\n  //     to = this.pages || 0;\n  //   }\n\n  //   for (let i = from; i <= to; i++) {\n  //     pagesArr.push(i);\n  //   }\n\n  //   this.pagesArray = Object.assign([], pagesArr);\n  // }\n\n  public setLoadMore(config: FsListLoadMoreConfig | boolean) {\n    const loadMoreConfig = typeof config === 'boolean' ? \n      {\n        enabled: !!config,\n      } : \n      (\n        config === undefined ? {} : {\n          ...config,\n          enabled: true,\n        }\n      );\n\n    this._loadMoreConfig = {\n      enabled: false,\n      label: 'Load More',\n      buttonType: 'basic',\n      ...loadMoreConfig,\n    };\n  }\n\n  /**\n   * Update dispayed records counter\n   */\n  // public updateDisplayed() {\n  //   this.displayed = this.getVisibleRecords();\n  // }\n\n  /**\n   * Return count of records that could be shown on page\n   */\n  // public getVisibleRecords() {\n  //   const diff = this.hasOffsetStrategy\n  //     ? this.records - this.offset\n  //     : this.limit;\n  //\n  //   return diff < this.limit\n  //     ? diff\n  //     : this.displayed;\n  // }\n\n  public getVisibleRecords() {\n    return this.displayed;\n  }\n\n  /**\n   * Set new limit\n   *\n   * @param limit\n   */\n  public setLimit(limit) {\n    this.limit = limit;\n    this.resetPaging();\n\n    this._pageChanged$.next({\n      type: PageChangeType.LimitChanged,\n      payload: limit,\n    });\n  }\n\n  /**\n   * If page is activate page\n   *\n   * @param page\n   */\n  public isActive(page): boolean {\n    return page === this.page;\n  }\n\n  /**\n   * Go to page\n   *\n   * @param page\n   */\n  public goToPage(page) {\n    if (page >= 1 && this.page !== page) {\n      this.page = page;\n\n      this._updateOffset();\n\n      this._pageChanged$.next({\n        type: PageChangeType.Default,\n        payload: page,\n      });\n    }\n  }\n\n  /**\n   * Reset paging like it was just initialized\n   */\n  public resetPaging() {\n    this.page = 1;\n    this.offset = 0;\n  }\n\n  /**\n   * Go to next page\n   */\n  public goNext() {\n    if (this.hasNextPage) {\n      this.page++;\n\n      this._updateOffset();\n\n      this._pageChanged$.next({\n        type: PageChangeType.Default,\n        payload: this.page,\n      });\n    }\n  }\n\n  /**\n   * Go to first page\n   */\n  public goFirst() {\n    if (this.page > 1) {\n      this.page = 1;\n\n      this._updateOffset();\n\n      this._pageChanged$.next({\n        type: PageChangeType.Default,\n        payload: this.page,\n      });\n    }\n  }\n\n  /**\n   * Go to prev page\n   */\n  public goPrev() {\n    if (this.page > 1) {\n      this.page--;\n\n      this._updateOffset();\n\n      this._pageChanged$.next({\n        type: PageChangeType.Default,\n        payload: this.page,\n      });\n    }\n  }\n\n  /**\n   * Go to last page\n   */\n  public goLast() {\n    if (this.page !== this.pages) {\n      this.page = this.pages;\n\n      this._updateOffset();\n\n      this._pageChanged$.next({\n        type: PageChangeType.Default,\n        payload: this.page,\n      });\n    }\n  }\n\n  /**\n   * Update count of deleted rows. This count will be applied for offset calc\n   *\n   * @param count\n   */\n  public removeRows(count: number) {\n    this._removedRows += count;\n  }\n\n  public updatePagination() {\n    this._updateTotalPages();\n  }\n\n  /**\n   * Destroy\n   */\n  public destroy() {\n    this._onDestroy$.next();\n    this._onDestroy$.complete();\n  }\n\n  /**\n   * Update paging state\n   *\n   * @param params\n   */\n  private _fromParams(params): void {\n    if (!this.loadMoreEnabled) {\n      this.limit = params.limit ?? 25;\n    }\n\n    this.records = params.records;\n    this.manual = params.manual;\n\n    this.pages = params.pages || 0;\n  }\n\n  /**\n   * Calc and update offset\n   */\n  private _updateOffset() {\n    this.offset = this.limit * (this.page - 1);\n  }\n\n  /**\n   * Calc and update total count of pages\n   */\n  private _updateTotalPages() {\n    this.pages = Math.ceil(this.records / this.limit);\n  }\n}\n"]}

package/esm2022/app/classes/persistance-controller.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { FsPersistanceStore, FsStore } from '@firestitch/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@firestitch/store";
+import * as i2 from "@angular/router";
+const FILTER_STORE_KEY = 'fs-list-persist';
+export class PersistanceController extends FsPersistanceStore {
+    STORE_KEY = FILTER_STORE_KEY;
+    constructor(_store, _route) {
+        super(_store, _route);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PersistanceController, deps: [{ token: i1.FsStore }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PersistanceController });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PersistanceController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FsStore }, { type: i2.ActivatedRoute }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyc2lzdGFuY2UtY29udHJvbGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvY2xhc3Nlcy9wZXJzaXN0YW5jZS1jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWpELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxPQUFPLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7OztBQUdoRSxNQUFNLGdCQUFnQixHQUFHLGlCQUFpQixDQUFDO0FBRzNDLE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxrQkFBb0M7SUFFbkUsU0FBUyxHQUFHLGdCQUFnQixDQUFDO0lBRXZDLFlBQ0UsTUFBZSxFQUNmLE1BQXNCO1FBRXRCLEtBQUssQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDeEIsQ0FBQzt3R0FUVSxxQkFBcUI7NEdBQXJCLHFCQUFxQjs7NEZBQXJCLHFCQUFxQjtrQkFEakMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuaW1wb3J0IHsgRnNQZXJzaXN0YW5jZVN0b3JlLCBGc1N0b3JlIH0gZnJvbSAnQGZpcmVzdGl0Y2gvc3RvcmUnO1xuaW1wb3J0IHsgRnNMaXN0UGVyc2l0YW5jZSB9IGZyb20gJy4uL2ludGVyZmFjZXMnO1xuXG5jb25zdCBGSUxURVJfU1RPUkVfS0VZID0gJ2ZzLWxpc3QtcGVyc2lzdCc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBQZXJzaXN0YW5jZUNvbnRyb2xsZXIgZXh0ZW5kcyBGc1BlcnNpc3RhbmNlU3RvcmU8RnNMaXN0UGVyc2l0YW5jZT4ge1xuXG4gIHByb3RlY3RlZCBTVE9SRV9LRVkgPSBGSUxURVJfU1RPUkVfS0VZO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIF9zdG9yZTogRnNTdG9yZSxcbiAgICBfcm91dGU6IEFjdGl2YXRlZFJvdXRlLFxuICApIHtcbiAgICBzdXBlcihfc3RvcmUsIF9yb3V0ZSk7XG4gIH1cblxufVxuIl19