@firestitch/list 12.20.1 → 13.0.1

package/esm2020/app/classes/external-params-controller.mjs

@@ -0,0 +1,147 @@
+import { merge, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+export class ExternalParamsController {
+    constructor(_router, _route, _persistance, _paginator, _sorting, _queryParamsEnabled) {
+        this._router = _router;
+        this._route = _route;
+        this._persistance = _persistance;
+        this._paginator = _paginator;
+        this._sorting = _sorting;
+        this._queryParamsEnabled = _queryParamsEnabled;
+        this._externalParams = {
+            page: null,
+            limit: null,
+            sortName: null,
+            sortDirection: null,
+        };
+        this._destroy$ = new Subject();
+        this.initialize();
+    }
+    get externalSorting() {
+        if (!this._enabled || !this._sortName || !this._sortDirection) {
+            return null;
+        }
+        return {
+            value: this._sortName,
+            direction: this._sortDirection,
+        };
+    }
+    get _enabled() {
+        return this._queryParamsEnabled || this._persistance.enabled;
+    }
+    get _page() {
+        return this._externalParams.page;
+    }
+    get _limit() {
+        return this._externalParams.limit;
+    }
+    get _sortName() {
+        return this._externalParams.sortName;
+    }
+    get _sortDirection() {
+        return this._externalParams.sortDirection;
+    }
+    initialize() {
+        // Restore from localStorage parameters if persistance enabled
+        if (this._persistance.enabled) {
+            this._restorePaginationParams(this._persistance.getDataFromScope('paging'));
+            this._restoreSortingParams(this._persistance.getDataFromScope('sorting'));
+        }
+        // Restore from queryParams and override if persistance already had values for those params
+        if (this._queryParamsEnabled) {
+            this._restorePaginationParams(this._route.snapshot.queryParams);
+            this._restoreSortingParams(this._route.snapshot.queryParams);
+        }
+        // Set initial pagination params
+        // The same initial, but for sorting placed in list-controller "tranformTemplatesToColumns" method
+        if (this._paginator.enabled && !this._paginator.infinityScrollEnabled) {
+            if (this._limit) {
+                this._paginator.setLimit(this._limit);
+            }
+            if (this._page) {
+                this._paginator.goToPage(this._page);
+            }
+        }
+        // Update pagination in stores
+        this._updatePaginationParams(this._paginator.queryPageStrategy);
+        this._listenPaginatorChanges();
+        this._listenSortingChanges();
+    }
+    clearSortingParams() {
+        this._updateSortingParams(null, null);
+    }
+    destroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    _restorePaginationParams(values) {
+        if (values?.page) {
+            this._externalParams.page = +values.page;
+        }
+        if (values?.limit) {
+            this._externalParams.limit = +values.limit;
+        }
+    }
+    _restoreSortingParams(values) {
+        if (values?.sortName) {
+            this._externalParams.sortName = values.sortName;
+        }
+        if (values?.sortDirection) {
+            this._externalParams.sortDirection = values.sortDirection;
+        }
+    }
+    _listenPaginatorChanges() {
+        merge(this._paginator.pageChanged$, this._paginator.pages$, this._paginator.pageReset$)
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this._updatePaginationParams(this._paginator.queryPageStrategy);
+        });
+    }
+    _listenSortingChanges() {
+        merge(this._sorting.initialized$, this._sorting.sortingChanged$)
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            const sorting = this._sorting.value;
+            if (sorting) {
+                this._updateSortingParams(sorting.value, sorting.direction);
+            }
+            else {
+                this.clearSortingParams();
+            }
+        });
+    }
+    _updateSortingParams(name, direction) {
+        if (this._queryParamsEnabled) {
+            this._replaceState({
+                sortName: name,
+                sortDirection: direction,
+            });
+        }
+        if (this._persistance.enabled) {
+            if (name && direction) {
+                this._persistance.saveDataToScope('sorting', { sortName: name, sortDirection: direction });
+            }
+            else {
+                this._persistance.saveDataToScope('sorting', null);
+            }
+        }
+    }
+    _updatePaginationParams(params) {
+        if (this._queryParamsEnabled) {
+            this._replaceState(params);
+        }
+        if (this._persistance.enabled) {
+            this._persistance.saveDataToScope('paging', params);
+        }
+    }
+    _replaceState(data) {
+        const url = new URL(window.location.href);
+        Object.keys(data)
+            .filter((name) => data[name] !== undefined && data[name] !== null)
+            .forEach((name) => {
+            url.searchParams.set(name, data[name]);
+        });
+        history.replaceState({}, null, url.pathname + url.search);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"external-params-controller.js","sourceRoot":"","sources":["../../../../src/app/classes/external-params-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActivatedRoute, Router } from '@angular/router';\n\nimport { merge, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { PaginationController } from '../classes/pagination-controller';\nimport { SortingController } from '../classes/sorting-controller';\nimport { FsListSortConfig } from '../interfaces';\nimport {\n  ExternalParams,\n  ExternalQueryPagination,\n  ExternalQuerySorting,\n} from '../interfaces/external-params.interface';\n\nimport { PersistanceController } from './persistance-controller';\n\n\nexport class ExternalParamsController {\n\n  private _externalParams: ExternalParams = {\n    page: null,\n    limit: null,\n    sortName: null,\n    sortDirection: null,\n  };\n\n  private _destroy$ = new Subject<void>();\n\n  constructor(\n    private _router: Router,\n    private _route: ActivatedRoute,\n    private _persistance: PersistanceController,\n    private _paginator: PaginationController,\n    private _sorting: SortingController,\n    private _queryParamsEnabled: boolean,\n  ) {\n    this.initialize();\n  }\n\n  public get externalSorting(): FsListSortConfig {\n    if (!this._enabled || !this._sortName || !this._sortDirection) {\n      return null;\n    }\n\n    return {\n      value: this._sortName,\n      direction: this._sortDirection,\n    };\n  }\n\n  private get _enabled(): boolean {\n    return this._queryParamsEnabled || this._persistance.enabled;\n  }\n\n  private get _page(): number {\n    return this._externalParams.page;\n  }\n\n  private get _limit(): number {\n    return this._externalParams.limit;\n  }\n\n  private get _sortName(): string {\n    return this._externalParams.sortName;\n  }\n\n  private get _sortDirection(): 'asc' | 'desc' {\n    return this._externalParams.sortDirection;\n  }\n\n  public initialize() {\n\n    // Restore from localStorage parameters if persistance enabled\n    if (this._persistance.enabled) {\n      this._restorePaginationParams(this._persistance.getDataFromScope('paging'));\n      this._restoreSortingParams(this._persistance.getDataFromScope('sorting'));\n    }\n\n    // Restore from queryParams and override if persistance already had values for those params\n    if (this._queryParamsEnabled) {\n      this._restorePaginationParams(this._route.snapshot.queryParams as ExternalQueryPagination);\n      this._restoreSortingParams(this._route.snapshot.queryParams as ExternalQuerySorting);\n    }\n\n    // Set initial pagination params\n    // The same initial, but for sorting placed in list-controller \"tranformTemplatesToColumns\" method\n    if (this._paginator.enabled && !this._paginator.infinityScrollEnabled) {\n      if (this._limit) {\n        this._paginator.setLimit(this._limit);\n      }\n\n      if (this._page) {\n        this._paginator.goToPage(this._page);\n\n      }\n    }\n\n    // Update pagination in stores\n    this._updatePaginationParams(this._paginator.queryPageStrategy);\n\n    this._listenPaginatorChanges();\n    this._listenSortingChanges();\n  }\n\n  public clearSortingParams() {\n    this._updateSortingParams(null, null);\n  }\n\n  public destroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  private _restorePaginationParams(values: ExternalQueryPagination) {\n    if (values?.page) {\n      this._externalParams.page = +values.page;\n    }\n\n    if (values?.limit) {\n      this._externalParams.limit = +values.limit;\n    }\n  }\n\n  private _restoreSortingParams(values: ExternalQuerySorting) {\n    if (values?.sortName) {\n      this._externalParams.sortName = values.sortName;\n    }\n\n    if (values?.sortDirection) {\n      this._externalParams.sortDirection = values.sortDirection;\n    }\n  }\n\n  private _listenPaginatorChanges() {\n    merge(\n      this._paginator.pageChanged$,\n      this._paginator.pages$,\n      this._paginator.pageReset$,\n    )\n      .pipe(\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this._updatePaginationParams(this._paginator.queryPageStrategy);\n      });\n  }\n\n  private _listenSortingChanges() {\n    merge(\n      this._sorting.initialized$,\n      this._sorting.sortingChanged$,\n    )\n      .pipe(\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        const sorting = this._sorting.value;\n\n        if (sorting) {\n          this._updateSortingParams(sorting.value, sorting.direction);\n        } else {\n          this.clearSortingParams();\n        }\n      });\n  }\n\n  private _updateSortingParams(name: string, direction: string) {\n    if (this._queryParamsEnabled) {\n      this._replaceState({\n        sortName: name,\n        sortDirection: direction,\n      });\n    }\n\n    if (this._persistance.enabled) {\n      if (name && direction) {\n        this._persistance.saveDataToScope('sorting', { sortName: name, sortDirection: direction });\n      } else {\n        this._persistance.saveDataToScope('sorting', null);\n      }\n    }\n  }\n\n  private _updatePaginationParams(params) {\n    if (this._queryParamsEnabled) {\n      this._replaceState(params);\n    }\n\n    if (this._persistance.enabled) {\n      this._persistance.saveDataToScope('paging', params);\n    }\n  }\n\n  private _replaceState(data) {\n    const url = new URL(window.location.href);\n\n    Object.keys(data)\n      .filter((name) => data[name] !== undefined && data[name] !== null)\n      .forEach((name) => {\n        url.searchParams.set(name,data[name]);\n      });\n\n    history.replaceState({}, null, url.pathname + url.search);\n  }\n}\n"]}