@vendure/admin-ui 1.4.7 → 2.0.0-next.0

package/esm2020/catalog/providers/routing/product-variants-resolver.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { BaseEntityResolver } from '@vendure/admin-ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@vendure/admin-ui/core";
+export class ProductVariantsResolver extends BaseEntityResolver {
+    constructor(router, dataService) {
+        super(router, {
+            __typename: 'Product',
+            id: '',
+            createdAt: '',
+            updatedAt: '',
+            name: '',
+            optionGroups: [],
+            variants: [],
+        }, id => dataService.product.getProductVariantsOptions(id).mapStream(data => data.product));
+    }
+}
+ProductVariantsResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductVariantsResolver, deps: [{ token: i1.Router }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductVariantsResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductVariantsResolver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductVariantsResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/catalog/public_api.mjs

@@ -0,0 +1,39 @@
+// This file was generated by the build-public-api.ts script
+export * from './catalog.module';
+export * from './catalog.routes';
+export * from './components/apply-facet-dialog/apply-facet-dialog.component';
+export * from './components/asset-detail/asset-detail.component';
+export * from './components/asset-list/asset-list.component';
+export * from './components/assets/assets.component';
+export * from './components/assign-products-to-channel-dialog/assign-products-to-channel-dialog.component';
+export * from './components/collection-contents/collection-contents.component';
+export * from './components/collection-detail/collection-detail.component';
+export * from './components/collection-list/collection-list.component';
+export * from './components/collection-tree/array-to-tree';
+export * from './components/collection-tree/collection-tree-node.component';
+export * from './components/collection-tree/collection-tree.component';
+export * from './components/collection-tree/collection-tree.service';
+export * from './components/collection-tree/collection-tree.types';
+export * from './components/confirm-variant-deletion-dialog/confirm-variant-deletion-dialog.component';
+export * from './components/facet-detail/facet-detail.component';
+export * from './components/facet-list/facet-list.component';
+export * from './components/generate-product-variants/generate-product-variants.component';
+export * from './components/option-value-input/option-value-input.component';
+export * from './components/product-detail/product-detail.component';
+export * from './components/product-detail/product-detail.types';
+export * from './components/product-list/product-list.component';
+export * from './components/product-options-editor/product-options-editor.component';
+export * from './components/product-search-input/product-search-input.component';
+export * from './components/product-variants-editor/product-variants-editor.component';
+export * from './components/product-variants-list/product-variants-list.component';
+export * from './components/product-variants-table/product-variants-table.component';
+export * from './components/update-product-option-dialog/update-product-option-dialog.component';
+export * from './components/variant-price-detail/variant-price-detail.component';
+export * from './providers/product-detail/product-detail.service';
+export * from './providers/product-detail/replace-last';
+export * from './providers/routing/asset-resolver';
+export * from './providers/routing/collection-resolver';
+export * from './providers/routing/facet-resolver';
+export * from './providers/routing/product-resolver';
+export * from './providers/routing/product-variants-resolver';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/app.component.mjs

@@ -0,0 +1,79 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, HostListener, Inject, isDevMode } from '@angular/core';
+import { filter, map, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./data/providers/data.service";
+import * as i2 from "./data/server-config";
+import * as i3 from "./providers/local-storage/local-storage.service";
+import * as i4 from "./components/overlay-host/overlay-host.component";
+import * as i5 from "@angular/router";
+import * as i6 from "@angular/common";
+export class AppComponent {
+    constructor(dataService, serverConfigService, localStorageService, document) {
+        this.dataService = dataService;
+        this.serverConfigService = serverConfigService;
+        this.localStorageService = localStorageService;
+        this.document = document;
+        this._document = document;
+    }
+    ngOnInit() {
+        this.loading$ = this.dataService.client
+            .getNetworkStatus()
+            .stream$.pipe(map(data => 0 < data.networkStatus.inFlightRequests));
+        this.dataService.client
+            .uiState()
+            .mapStream(data => data.uiState.theme)
+            .subscribe(theme => {
+            this._document?.body.setAttribute('data-theme', theme);
+        });
+        // Once logged in, keep the localStorage "contentLanguageCode" in sync with the
+        // uiState. Also perform a check to ensure that the current contentLanguage is
+        // one of the availableLanguages per GlobalSettings.
+        this.dataService.client
+            .userStatus()
+            .mapStream(({ userStatus }) => userStatus.isLoggedIn)
+            .pipe(filter(loggedIn => loggedIn === true), switchMap(() => {
+            return this.dataService.client.uiState().mapStream(data => data.uiState.contentLanguage);
+        }), switchMap(contentLang => {
+            return this.serverConfigService
+                .getAvailableLanguages()
+                .pipe(map(available => [contentLang, available]));
+        }))
+            .subscribe({
+            next: ([contentLanguage, availableLanguages]) => {
+                this.localStorageService.set('contentLanguageCode', contentLanguage);
+                if (availableLanguages.length && !availableLanguages.includes(contentLanguage)) {
+                    this.dataService.client.setContentLanguage(availableLanguages[0]).subscribe();
+                }
+            },
+        });
+        if (isDevMode()) {
+            // tslint:disable-next-line:no-console
+            console.log(`%cVendure Admin UI: Press "ctrl/cmd + u" to view UI extension points`, `color: #17C1FF; font-weight: bold;`);
+        }
+    }
+    handleGlobalHotkeys(event) {
+        if ((event.ctrlKey === true || event.metaKey === true) && event.key === 'u') {
+            event.preventDefault();
+            if (isDevMode()) {
+                this.dataService.client
+                    .uiState()
+                    .single$.pipe(switchMap(({ uiState }) => this.dataService.client.setDisplayUiExtensionPoints(!uiState.displayUiExtensionPoints)))
+                    .subscribe();
+            }
+        }
+    }
+}
+AppComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppComponent, deps: [{ token: i1.DataService }, { token: i2.ServerConfigService }, { token: i3.LocalStorageService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+AppComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: AppComponent, selector: "vdr-root", host: { listeners: { "window:keydown": "handleGlobalHotkeys($event)" } }, ngImport: i0, template: "<div class=\"progress loop\" [class.visible]=\"loading$ | async\"></div>\r\n<router-outlet></router-outlet>\r\n<vdr-overlay-host></vdr-overlay-host>\r\n", styles: [".progress{position:absolute;overflow:hidden;height:4px;background-color:var(--color-grey-500);opacity:0;transition:opacity .1s}.progress.visible{opacity:1}\n"], components: [{ type: i4.OverlayHostComponent, selector: "vdr-overlay-host" }], directives: [{ type: i5.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }], pipes: { "async": i6.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-root', template: "<div class=\"progress loop\" [class.visible]=\"loading$ | async\"></div>\r\n<router-outlet></router-outlet>\r\n<vdr-overlay-host></vdr-overlay-host>\r\n", styles: [".progress{position:absolute;overflow:hidden;height:4px;background-color:var(--color-grey-500);opacity:0;transition:opacity .1s}.progress.visible{opacity:1}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i2.ServerConfigService }, { type: i3.LocalStorageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { handleGlobalHotkeys: [{
+                type: HostListener,
+                args: ['window:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.component.js","sourceRoot":"","sources":["../../../src/lib/core/src/app.component.ts","../../../src/lib/core/src/app.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport { Component, HostListener, Inject, isDevMode, OnInit } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { filter, map, switchMap } from 'rxjs/operators';\r\n\r\nimport { DataService } from './data/providers/data.service';\r\nimport { ServerConfigService } from './data/server-config';\r\nimport { LocalStorageService } from './providers/local-storage/local-storage.service';\r\n\r\n@Component({\r\n    selector: 'vdr-root',\r\n    templateUrl: './app.component.html',\r\n    styleUrls: ['./app.component.scss'],\r\n})\r\nexport class AppComponent implements OnInit {\r\n    loading$: Observable<boolean>;\r\n    private _document?: Document;\r\n\r\n    constructor(\r\n        private dataService: DataService,\r\n        private serverConfigService: ServerConfigService,\r\n        private localStorageService: LocalStorageService,\r\n        @Inject(DOCUMENT) private document?: any,\r\n    ) {\r\n        this._document = document;\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.loading$ = this.dataService.client\r\n            .getNetworkStatus()\r\n            .stream$.pipe(map(data => 0 < data.networkStatus.inFlightRequests));\r\n\r\n        this.dataService.client\r\n            .uiState()\r\n            .mapStream(data => data.uiState.theme)\r\n            .subscribe(theme => {\r\n                this._document?.body.setAttribute('data-theme', theme);\r\n            });\r\n\r\n        // Once logged in, keep the localStorage \"contentLanguageCode\" in sync with the\r\n        // uiState. Also perform a check to ensure that the current contentLanguage is\r\n        // one of the availableLanguages per GlobalSettings.\r\n        this.dataService.client\r\n            .userStatus()\r\n            .mapStream(({ userStatus }) => userStatus.isLoggedIn)\r\n            .pipe(\r\n                filter(loggedIn => loggedIn === true),\r\n                switchMap(() => {\r\n                    return this.dataService.client.uiState().mapStream(data => data.uiState.contentLanguage);\r\n                }),\r\n                switchMap(contentLang => {\r\n                    return this.serverConfigService\r\n                        .getAvailableLanguages()\r\n                        .pipe(map(available => [contentLang, available] as const));\r\n                }),\r\n            )\r\n            .subscribe({\r\n                next: ([contentLanguage, availableLanguages]) => {\r\n                    this.localStorageService.set('contentLanguageCode', contentLanguage);\r\n                    if (availableLanguages.length && !availableLanguages.includes(contentLanguage)) {\r\n                        this.dataService.client.setContentLanguage(availableLanguages[0]).subscribe();\r\n                    }\r\n                },\r\n            });\r\n\r\n        if (isDevMode()) {\r\n            // tslint:disable-next-line:no-console\r\n            console.log(\r\n                `%cVendure Admin UI: Press \"ctrl/cmd + u\" to view UI extension points`,\r\n                `color: #17C1FF; font-weight: bold;`,\r\n            );\r\n        }\r\n    }\r\n\r\n    @HostListener('window:keydown', ['$event'])\r\n    handleGlobalHotkeys(event: KeyboardEvent) {\r\n        if ((event.ctrlKey === true || event.metaKey === true) && event.key === 'u') {\r\n            event.preventDefault();\r\n            if (isDevMode()) {\r\n                this.dataService.client\r\n                    .uiState()\r\n                    .single$.pipe(\r\n                        switchMap(({ uiState }) =>\r\n                            this.dataService.client.setDisplayUiExtensionPoints(\r\n                                !uiState.displayUiExtensionPoints,\r\n                            ),\r\n                        ),\r\n                    )\r\n                    .subscribe();\r\n            }\r\n        }\r\n    }\r\n}\r\n","<div class=\"progress loop\" [class.visible]=\"loading$ | async\"></div>\r\n<router-outlet></router-outlet>\r\n<vdr-overlay-host></vdr-overlay-host>\r\n"]}

package/esm2020/core/app.component.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { AppComponent } from './app.component';
+import { CoreModule } from './core.module';
+import { SharedModule } from './shared/shared.module';
+import * as i0 from "@angular/core";
+export class AppComponentModule {
+}
+AppComponentModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppComponentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppComponentModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppComponentModule, declarations: [AppComponent], imports: [SharedModule, CoreModule], exports: [AppComponent] });
+AppComponentModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppComponentModule, imports: [[SharedModule, CoreModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppComponentModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [SharedModule, CoreModule],
+                    declarations: [AppComponent],
+                    exports: [AppComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmNvbXBvbmVudC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2FwcC5jb21wb25lbnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQU90RCxNQUFNLE9BQU8sa0JBQWtCOzsrR0FBbEIsa0JBQWtCO2dIQUFsQixrQkFBa0IsaUJBSFosWUFBWSxhQURqQixZQUFZLEVBQUUsVUFBVSxhQUV4QixZQUFZO2dIQUViLGtCQUFrQixZQUpsQixDQUFDLFlBQVksRUFBRSxVQUFVLENBQUM7MkZBSTFCLGtCQUFrQjtrQkFMOUIsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsVUFBVSxDQUFDO29CQUNuQyxZQUFZLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQzVCLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztpQkFDMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuaW1wb3J0IHsgQXBwQ29tcG9uZW50IH0gZnJvbSAnLi9hcHAuY29tcG9uZW50JztcclxuaW1wb3J0IHsgQ29yZU1vZHVsZSB9IGZyb20gJy4vY29yZS5tb2R1bGUnO1xyXG5pbXBvcnQgeyBTaGFyZWRNb2R1bGUgfSBmcm9tICcuL3NoYXJlZC9zaGFyZWQubW9kdWxlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBpbXBvcnRzOiBbU2hhcmVkTW9kdWxlLCBDb3JlTW9kdWxlXSxcclxuICAgIGRlY2xhcmF0aW9uczogW0FwcENvbXBvbmVudF0sXHJcbiAgICBleHBvcnRzOiBbQXBwQ29tcG9uZW50XSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEFwcENvbXBvbmVudE1vZHVsZSB7fVxyXG4iXX0=

package/esm2020/core/common/base-detail.component.mjs

@@ -0,0 +1,108 @@
+import { combineLatest, of, Subject } from 'rxjs';
+import { distinctUntilChanged, map, shareReplay, switchMap, takeUntil, tap } from 'rxjs/operators';
+/**
+ * @description
+ * A base class for entity detail views. It should be used in conjunction with the
+ * {@link BaseEntityResolver}.
+ *
+ * @example
+ * ```TypeScript
+ * \@Component({
+ *   selector: 'app-my-entity',
+ *   templateUrl: './my-entity.component.html',
+ *   styleUrls: ['./my-entity.component.scss'],
+ *   changeDetection: ChangeDetectionStrategy.OnPush,
+ * })
+ * export class GlobalSettingsComponent extends BaseDetailComponent<MyEntityFragment> implements OnInit {
+ *   detailForm: FormGroup;
+ *
+ *   constructor(
+ *     router: Router,
+ *     route: ActivatedRoute,
+ *     serverConfigService: ServerConfigService,
+ *     protected dataService: DataService,
+ *     private formBuilder: FormBuilder,
+ *   ) {
+ *     super(route, router, serverConfigService, dataService);
+ *     this.detailForm = this.formBuilder.group({
+ *       name: [''],
+ *     });
+ *   }
+ *
+ *   protected setFormValues(entity: MyEntityFragment, languageCode: LanguageCode): void {
+ *     this.detailForm.patchValue({
+ *       name: entity.name,
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @docsCategory list-detail-views
+ */
+export class BaseDetailComponent {
+    constructor(route, router, serverConfigService, dataService) {
+        this.route = route;
+        this.router = router;
+        this.serverConfigService = serverConfigService;
+        this.dataService = dataService;
+        this.destroy$ = new Subject();
+    }
+    init() {
+        this.entity$ = this.route.data.pipe(switchMap(data => data.entity.pipe(takeUntil(this.destroy$))), tap(entity => (this.id = entity.id)), shareReplay(1));
+        this.isNew$ = this.entity$.pipe(map(entity => entity.id === ''), shareReplay(1));
+        this.languageCode$ = this.route.paramMap.pipe(map(paramMap => paramMap.get('lang')), switchMap(lang => {
+            if (lang) {
+                return of(lang);
+            }
+            else {
+                return this.dataService.client.uiState().mapSingle(data => data.uiState.contentLanguage);
+            }
+        }), distinctUntilChanged(), shareReplay(1));
+        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();
+        combineLatest(this.entity$, this.languageCode$)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(([entity, languageCode]) => {
+            this.setFormValues(entity, languageCode);
+            this.detailForm.markAsPristine();
+        });
+    }
+    destroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    setLanguage(code) {
+        this.setQueryParam('lang', code);
+        this.dataService.client.setContentLanguage(code).subscribe();
+    }
+    canDeactivate() {
+        return this.detailForm && this.detailForm.pristine;
+    }
+    setCustomFieldFormValues(customFields, formGroup, entity, currentTranslation) {
+        for (const fieldDef of customFields) {
+            const key = fieldDef.name;
+            const value = fieldDef.type === 'localeString'
+                ? currentTranslation?.customFields?.[key]
+                : entity.customFields?.[key];
+            const control = formGroup?.get(key);
+            if (control) {
+                control.patchValue(value);
+            }
+        }
+    }
+    getCustomFieldConfig(key) {
+        return this.serverConfigService.getCustomFieldsFor(key);
+    }
+    setQueryParam(key, value) {
+        this.router.navigate([
+            './',
+            {
+                ...this.route.snapshot.params,
+                [key]: value,
+            },
+        ], {
+            relativeTo: this.route,
+            queryParamsHandling: 'merge',
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-detail.component.js","sourceRoot":"","sources":["../../../../src/lib/core/src/common/base-detail.component.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAc,EAAE,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAUnG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,OAAgB,mBAAmB;IAWrC,YACc,KAAqB,EACrB,MAAc,EACd,mBAAwC,EACxC,WAAwB;QAHxB,UAAK,GAAL,KAAK,CAAgB;QACrB,WAAM,GAAN,MAAM,CAAQ;QACd,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,gBAAW,GAAX,WAAW,CAAa;QAN5B,aAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;IAOtC,CAAC;IAEJ,IAAI;QACA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAC/B,SAAS,CAAC,IAAI,CAAC,EAAE,CAAE,IAAI,CAAC,MAA6B,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EACrF,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,EACpC,WAAW,CAAC,CAAC,CAAC,CACjB,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAC3B,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAC/B,WAAW,CAAC,CAAC,CAAC,CACjB,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CACzC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EACrC,SAAS,CAAC,IAAI,CAAC,EAAE;YACb,IAAI,IAAI,EAAE;gBACN,OAAO,EAAE,CAAC,IAAoB,CAAC,CAAC;aACnC;iBAAM;gBACH,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;aAC5F;QACL,CAAC,CAAC,EACF,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,CACjB,CAAC;QAEF,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC,qBAAqB,EAAE,CAAC;QAE5E,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC;aAC1C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC9B,SAAS,CAAC,CAAC,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,EAAE;YAClC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YACzC,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;QACrC,CAAC,CAAC,CAAC;IACX,CAAC;IAED,OAAO;QACH,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,WAAW,CAAC,IAAkB;QAC1B,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;IACjE,CAAC;IAED,aAAa;QACT,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;IACvD,CAAC;IAIS,wBAAwB,CAC9B,YAAiC,EACjC,SAAiC,EACjC,MAAS,EACT,kBAAqC;QAErC,KAAK,MAAM,QAAQ,IAAI,YAAY,EAAE;YACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC;YAC1B,MAAM,KAAK,GACP,QAAQ,CAAC,IAAI,KAAK,cAAc;gBAC5B,CAAC,CAAE,kBAA0B,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC;gBAClD,CAAC,CAAE,MAAc,CAAC,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC;YAC9C,MAAM,OAAO,GAAG,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,IAAI,OAAO,EAAE;gBACT,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;aAC7B;SACJ;IACL,CAAC;IAES,oBAAoB,CAAC,GAA8C;QACzE,OAAO,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;IAES,aAAa,CAAC,GAAW,EAAE,KAAU;QAC3C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAChB;YACI,IAAI;YACJ;gBACI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM;gBAC7B,CAAC,GAAG,CAAC,EAAE,KAAK;aACf;SACJ,EACD;YACI,UAAU,EAAE,IAAI,CAAC,KAAK;YACtB,mBAAmB,EAAE,OAAO;SAC/B,CACJ,CAAC;IACN,CAAC;CACJ","sourcesContent":["import { AbstractControl, FormGroup } from '@angular/forms';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { combineLatest, Observable, of, Subject } from 'rxjs';\r\nimport { distinctUntilChanged, map, shareReplay, switchMap, takeUntil, tap } from 'rxjs/operators';\r\n\r\nimport { DataService } from '../data/providers/data.service';\r\nimport { ServerConfigService } from '../data/server-config';\r\n\r\nimport { DeactivateAware } from './deactivate-aware';\r\nimport { CustomFieldConfig, CustomFields, LanguageCode } from './generated-types';\r\nimport { TranslationOf } from './utilities/find-translation';\r\nimport { getDefaultUiLanguage } from './utilities/get-default-ui-language';\r\n\r\n/**\r\n * @description\r\n * A base class for entity detail views. It should be used in conjunction with the\r\n * {@link BaseEntityResolver}.\r\n *\r\n * @example\r\n * ```TypeScript\r\n * \\@Component({\r\n *   selector: 'app-my-entity',\r\n *   templateUrl: './my-entity.component.html',\r\n *   styleUrls: ['./my-entity.component.scss'],\r\n *   changeDetection: ChangeDetectionStrategy.OnPush,\r\n * })\r\n * export class GlobalSettingsComponent extends BaseDetailComponent<MyEntityFragment> implements OnInit {\r\n *   detailForm: FormGroup;\r\n *\r\n *   constructor(\r\n *     router: Router,\r\n *     route: ActivatedRoute,\r\n *     serverConfigService: ServerConfigService,\r\n *     protected dataService: DataService,\r\n *     private formBuilder: FormBuilder,\r\n *   ) {\r\n *     super(route, router, serverConfigService, dataService);\r\n *     this.detailForm = this.formBuilder.group({\r\n *       name: [''],\r\n *     });\r\n *   }\r\n *\r\n *   protected setFormValues(entity: MyEntityFragment, languageCode: LanguageCode): void {\r\n *     this.detailForm.patchValue({\r\n *       name: entity.name,\r\n *     });\r\n *   }\r\n * }\r\n * ```\r\n *\r\n * @docsCategory list-detail-views\r\n */\r\nexport abstract class BaseDetailComponent<Entity extends { id: string; updatedAt?: string }>\r\n    implements DeactivateAware\r\n{\r\n    entity$: Observable<Entity>;\r\n    availableLanguages$: Observable<LanguageCode[]>;\r\n    languageCode$: Observable<LanguageCode>;\r\n    isNew$: Observable<boolean>;\r\n    id: string;\r\n    abstract detailForm: FormGroup;\r\n    protected destroy$ = new Subject<void>();\r\n\r\n    protected constructor(\r\n        protected route: ActivatedRoute,\r\n        protected router: Router,\r\n        protected serverConfigService: ServerConfigService,\r\n        protected dataService: DataService,\r\n    ) {}\r\n\r\n    init() {\r\n        this.entity$ = this.route.data.pipe(\r\n            switchMap(data => (data.entity as Observable<Entity>).pipe(takeUntil(this.destroy$))),\r\n            tap(entity => (this.id = entity.id)),\r\n            shareReplay(1),\r\n        );\r\n        this.isNew$ = this.entity$.pipe(\r\n            map(entity => entity.id === ''),\r\n            shareReplay(1),\r\n        );\r\n        this.languageCode$ = this.route.paramMap.pipe(\r\n            map(paramMap => paramMap.get('lang')),\r\n            switchMap(lang => {\r\n                if (lang) {\r\n                    return of(lang as LanguageCode);\r\n                } else {\r\n                    return this.dataService.client.uiState().mapSingle(data => data.uiState.contentLanguage);\r\n                }\r\n            }),\r\n            distinctUntilChanged(),\r\n            shareReplay(1),\r\n        );\r\n\r\n        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();\r\n\r\n        combineLatest(this.entity$, this.languageCode$)\r\n            .pipe(takeUntil(this.destroy$))\r\n            .subscribe(([entity, languageCode]) => {\r\n                this.setFormValues(entity, languageCode);\r\n                this.detailForm.markAsPristine();\r\n            });\r\n    }\r\n\r\n    destroy() {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    setLanguage(code: LanguageCode) {\r\n        this.setQueryParam('lang', code);\r\n        this.dataService.client.setContentLanguage(code).subscribe();\r\n    }\r\n\r\n    canDeactivate(): boolean {\r\n        return this.detailForm && this.detailForm.pristine;\r\n    }\r\n\r\n    protected abstract setFormValues(entity: Entity, languageCode: LanguageCode): void;\r\n\r\n    protected setCustomFieldFormValues<T = Entity>(\r\n        customFields: CustomFieldConfig[],\r\n        formGroup: AbstractControl | null,\r\n        entity: T,\r\n        currentTranslation?: TranslationOf<T>,\r\n    ) {\r\n        for (const fieldDef of customFields) {\r\n            const key = fieldDef.name;\r\n            const value =\r\n                fieldDef.type === 'localeString'\r\n                    ? (currentTranslation as any)?.customFields?.[key]\r\n                    : (entity as any).customFields?.[key];\r\n            const control = formGroup?.get(key);\r\n            if (control) {\r\n                control.patchValue(value);\r\n            }\r\n        }\r\n    }\r\n\r\n    protected getCustomFieldConfig(key: Exclude<keyof CustomFields, '__typename'>): CustomFieldConfig[] {\r\n        return this.serverConfigService.getCustomFieldsFor(key);\r\n    }\r\n\r\n    protected setQueryParam(key: string, value: any) {\r\n        this.router.navigate(\r\n            [\r\n                './',\r\n                {\r\n                    ...this.route.snapshot.params,\r\n                    [key]: value,\r\n                },\r\n            ],\r\n            {\r\n                relativeTo: this.route,\r\n                queryParamsHandling: 'merge',\r\n            },\r\n        );\r\n    }\r\n}\r\n"]}

package/{esm2015/core/common/base-entity-resolver.js → esm2020/core/common/base-entity-resolver.mjs}

@@ -18,7 +18,7 @@ export function createResolveData(resolver) {
  * \@Injectable({
  *   providedIn: 'root',
  * })
- * export class MyEntityResolver extends BaseEntityResolver<MyEntity.Fragment> {
+ * export class MyEntityResolver extends BaseEntityResolver<MyEntityFragment> {
  *   constructor(router: Router, dataService: DataService) {
  *     super(
  *       router,
@@ -57,4 +57,4 @@ export class BaseEntityResolver {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common/base-list.component.mjs

@@ -0,0 +1,159 @@
+import { Directive } from '@angular/core';
+import { BehaviorSubject, combineLatest, Subject } from 'rxjs';
+import { distinctUntilChanged, map, shareReplay, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/**
+ * @description
+ * This is a base class which implements the logic required to fetch and manipulate
+ * a list of data from a query which returns a PaginatedList type.
+ *
+ * @example
+ * ```TypeScript
+ * \@Component({
+ *   selector: 'my-entity-list',
+ *   templateUrl: './my-entity-list.component.html',
+ *   styleUrls: ['./my-entity-list.component.scss'],
+ *   changeDetection: ChangeDetectionStrategy.OnPush,
+ * })
+ * export class MyEntityListComponent extends BaseListComponent<GetMyEntityList.Query, GetMyEntityList.Items> {
+ *   constructor(
+ *     private dataService: DataService,
+ *     router: Router,
+ *     route: ActivatedRoute,
+ *   ) {
+ *     super(router, route);
+ *     super.setQueryFn(
+ *       (...args: any[]) => this.dataService.query<GetMyEntityList.Query>(GET_MY_ENTITY_LIST),
+ *       data => data.myEntities,
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * The template for the component will typically use the {@link DataTableComponent} to display the results.
+ *
+ * @example
+ * ```HTML
+ * <vdr-action-bar>
+ *   <vdr-ab-right>
+ *     <a class="btn btn-primary" [routerLink]="['./create']" *vdrIfPermissions="['CreateSettings', 'CreateTaxRate']">
+ *       <clr-icon shape="plus"></clr-icon>
+ *       Create new my entity
+ *     </a>
+ *   </vdr-ab-right>
+ * </vdr-action-bar>
+ *
+ * <vdr-data-table
+ *   [items]="items$ | async"
+ *   [itemsPerPage]="itemsPerPage$ | async"
+ *   [totalItems]="totalItems$ | async"
+ *   [currentPage]="currentPage$ | async"
+ *   (pageChange)="setPageNumber($event)"
+ *   (itemsPerPageChange)="setItemsPerPage($event)"
+ * >
+ *   <vdr-dt-column>{{ 'common.name' | translate }}</vdr-dt-column>
+ *   <vdr-dt-column></vdr-dt-column>
+ *   <ng-template let-myEntity="item">
+ *     <td class="left align-middle">{{ myEntity.name }}</td>
+ *     <td class="right align-middle">
+ *       <vdr-table-row-action
+ *         iconShape="edit"
+ *         [label]="'common.edit' | translate"
+ *         [linkTo]="['./', myEntity.id]"
+ *       ></vdr-table-row-action>
+ *     </td>
+ *   </ng-template>
+ * </vdr-data-table>
+ * ```
+ *
+ * @docsCategory list-detail-views
+ */
+// tslint:disable-next-line:directive-class-suffix
+export class BaseListComponent {
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+        this.destroy$ = new Subject();
+        this.onPageChangeFn = (skip, take) => ({ options: { skip, take } });
+        this.refresh$ = new BehaviorSubject(undefined);
+        this.defaults = { take: 10, skip: 0 };
+    }
+    /**
+     * @description
+     * Sets the fetch function for the list being implemented.
+     */
+    setQueryFn(listQueryFn, mappingFn, onPageChangeFn, defaults) {
+        this.listQueryFn = listQueryFn;
+        this.mappingFn = mappingFn;
+        if (onPageChangeFn) {
+            this.onPageChangeFn = onPageChangeFn;
+        }
+        if (defaults) {
+            this.defaults = defaults;
+        }
+    }
+    /** @internal */
+    ngOnInit() {
+        if (!this.listQueryFn) {
+            throw new Error(`No listQueryFn has been defined. Please call super.setQueryFn() in the constructor.`);
+        }
+        this.listQuery = this.listQueryFn(this.defaults.take, this.defaults.skip);
+        const fetchPage = ([currentPage, itemsPerPage, _]) => {
+            const take = itemsPerPage;
+            const skip = (currentPage - 1) * itemsPerPage;
+            this.listQuery.ref.refetch(this.onPageChangeFn(skip, take));
+        };
+        this.result$ = this.listQuery.stream$.pipe(shareReplay(1));
+        this.items$ = this.result$.pipe(map(data => this.mappingFn(data).items));
+        this.totalItems$ = this.result$.pipe(map(data => this.mappingFn(data).totalItems));
+        this.currentPage$ = this.route.queryParamMap.pipe(map(qpm => qpm.get('page')), map(page => (!page ? 1 : +page)), distinctUntilChanged());
+        this.itemsPerPage$ = this.route.queryParamMap.pipe(map(qpm => qpm.get('perPage')), map(perPage => (!perPage ? this.defaults.take : +perPage)), distinctUntilChanged());
+        combineLatest(this.currentPage$, this.itemsPerPage$, this.refresh$)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(fetchPage);
+    }
+    /** @internal */
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.listQuery.completed$.next();
+    }
+    /**
+     * @description
+     * Sets the current page number in the url.
+     */
+    setPageNumber(page) {
+        this.setQueryParam('page', page, { replaceUrl: true });
+    }
+    /**
+     * @description
+     * Sets the number of items per page in the url.
+     */
+    setItemsPerPage(perPage) {
+        this.setQueryParam('perPage', perPage, { replaceUrl: true });
+    }
+    /**
+     * @description
+     * Re-fetch the current page of results.
+     */
+    refresh() {
+        this.refresh$.next(undefined);
+    }
+    setQueryParam(keyOrHash, valueOrOptions, maybeOptions) {
+        const paramsObject = typeof keyOrHash === 'string' ? { [keyOrHash]: valueOrOptions } : keyOrHash;
+        const options = (typeof keyOrHash === 'string' ? maybeOptions : valueOrOptions) ?? {};
+        this.router.navigate(['./'], {
+            queryParams: typeof keyOrHash === 'string' ? { [keyOrHash]: valueOrOptions } : keyOrHash,
+            relativeTo: this.route,
+            queryParamsHandling: 'merge',
+            ...options,
+        });
+    }
+}
+BaseListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: BaseListComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Directive });
+BaseListComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: BaseListComponent, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: BaseListComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-list.component.js","sourceRoot":"","sources":["../../../../src/lib/core/src/common/base-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, OnDestroy, OnInit } from '@angular/core';\r\nimport { ActivatedRoute, QueryParamsHandling, Router } from '@angular/router';\r\nimport { PaginatedList } from '@vendure/common/lib/shared-types';\r\nimport { BehaviorSubject, combineLatest, Observable, Subject } from 'rxjs';\r\nimport { distinctUntilChanged, map, shareReplay, takeUntil } from 'rxjs/operators';\r\n\r\nimport { QueryResult } from '../data/query-result';\r\n\r\nexport type ListQueryFn<R> = (take: number, skip: number, ...args: any[]) => QueryResult<R, any>;\r\nexport type MappingFn<T, R> = (result: R) => { items: T[]; totalItems: number };\r\nexport type OnPageChangeFn<V> = (skip: number, take: number) => V;\r\n/**\r\n * Unwraps a query that returns a paginated list with an \"items\" property,\r\n * returning the type of one of the items in the array.\r\n */\r\nexport type ItemOf<T, K extends keyof T> = T[K] extends { items: infer R }\r\n    ? R extends any[]\r\n        ? R[number]\r\n        : R\r\n    : never;\r\n/**\r\n * @description\r\n * This is a base class which implements the logic required to fetch and manipulate\r\n * a list of data from a query which returns a PaginatedList type.\r\n *\r\n * @example\r\n * ```TypeScript\r\n * \\@Component({\r\n *   selector: 'my-entity-list',\r\n *   templateUrl: './my-entity-list.component.html',\r\n *   styleUrls: ['./my-entity-list.component.scss'],\r\n *   changeDetection: ChangeDetectionStrategy.OnPush,\r\n * })\r\n * export class MyEntityListComponent extends BaseListComponent<GetMyEntityList.Query, GetMyEntityList.Items> {\r\n *   constructor(\r\n *     private dataService: DataService,\r\n *     router: Router,\r\n *     route: ActivatedRoute,\r\n *   ) {\r\n *     super(router, route);\r\n *     super.setQueryFn(\r\n *       (...args: any[]) => this.dataService.query<GetMyEntityList.Query>(GET_MY_ENTITY_LIST),\r\n *       data => data.myEntities,\r\n *     );\r\n *   }\r\n * }\r\n * ```\r\n *\r\n * The template for the component will typically use the {@link DataTableComponent} to display the results.\r\n *\r\n * @example\r\n * ```HTML\r\n * <vdr-action-bar>\r\n *   <vdr-ab-right>\r\n *     <a class=\"btn btn-primary\" [routerLink]=\"['./create']\" *vdrIfPermissions=\"['CreateSettings', 'CreateTaxRate']\">\r\n *       <clr-icon shape=\"plus\"></clr-icon>\r\n *       Create new my entity\r\n *     </a>\r\n *   </vdr-ab-right>\r\n * </vdr-action-bar>\r\n *\r\n * <vdr-data-table\r\n *   [items]=\"items$ | async\"\r\n *   [itemsPerPage]=\"itemsPerPage$ | async\"\r\n *   [totalItems]=\"totalItems$ | async\"\r\n *   [currentPage]=\"currentPage$ | async\"\r\n *   (pageChange)=\"setPageNumber($event)\"\r\n *   (itemsPerPageChange)=\"setItemsPerPage($event)\"\r\n * >\r\n *   <vdr-dt-column>{{ 'common.name' | translate }}</vdr-dt-column>\r\n *   <vdr-dt-column></vdr-dt-column>\r\n *   <ng-template let-myEntity=\"item\">\r\n *     <td class=\"left align-middle\">{{ myEntity.name }}</td>\r\n *     <td class=\"right align-middle\">\r\n *       <vdr-table-row-action\r\n *         iconShape=\"edit\"\r\n *         [label]=\"'common.edit' | translate\"\r\n *         [linkTo]=\"['./', myEntity.id]\"\r\n *       ></vdr-table-row-action>\r\n *     </td>\r\n *   </ng-template>\r\n * </vdr-data-table>\r\n * ```\r\n *\r\n * @docsCategory list-detail-views\r\n */\r\n@Directive()\r\n// tslint:disable-next-line:directive-class-suffix\r\nexport class BaseListComponent<ResultType, ItemType, VariableType = any> implements OnInit, OnDestroy {\r\n    result$: Observable<ResultType>;\r\n    items$: Observable<ItemType[]>;\r\n    totalItems$: Observable<number>;\r\n    itemsPerPage$: Observable<number>;\r\n    currentPage$: Observable<number>;\r\n    protected destroy$ = new Subject<void>();\r\n    private listQuery: QueryResult<ResultType, VariableType>;\r\n    private listQueryFn: ListQueryFn<ResultType>;\r\n    private mappingFn: MappingFn<ItemType, ResultType>;\r\n    private onPageChangeFn: OnPageChangeFn<VariableType> = (skip, take) =>\r\n        ({ options: { skip, take } } as any);\r\n    private refresh$ = new BehaviorSubject<undefined>(undefined);\r\n    private defaults: { take: number; skip: number } = { take: 10, skip: 0 };\r\n\r\n    constructor(protected router: Router, protected route: ActivatedRoute) {}\r\n\r\n    /**\r\n     * @description\r\n     * Sets the fetch function for the list being implemented.\r\n     */\r\n    setQueryFn(\r\n        listQueryFn: ListQueryFn<ResultType>,\r\n        mappingFn: MappingFn<ItemType, ResultType>,\r\n        onPageChangeFn?: OnPageChangeFn<VariableType>,\r\n        defaults?: { take: number; skip: number },\r\n    ) {\r\n        this.listQueryFn = listQueryFn;\r\n        this.mappingFn = mappingFn;\r\n        if (onPageChangeFn) {\r\n            this.onPageChangeFn = onPageChangeFn;\r\n        }\r\n        if (defaults) {\r\n            this.defaults = defaults;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    ngOnInit() {\r\n        if (!this.listQueryFn) {\r\n            throw new Error(\r\n                `No listQueryFn has been defined. Please call super.setQueryFn() in the constructor.`,\r\n            );\r\n        }\r\n        this.listQuery = this.listQueryFn(this.defaults.take, this.defaults.skip);\r\n\r\n        const fetchPage = ([currentPage, itemsPerPage, _]: [number, number, undefined]) => {\r\n            const take = itemsPerPage;\r\n            const skip = (currentPage - 1) * itemsPerPage;\r\n            this.listQuery.ref.refetch(this.onPageChangeFn(skip, take));\r\n        };\r\n\r\n        this.result$ = this.listQuery.stream$.pipe(shareReplay(1));\r\n        this.items$ = this.result$.pipe(map(data => this.mappingFn(data).items));\r\n        this.totalItems$ = this.result$.pipe(map(data => this.mappingFn(data).totalItems));\r\n        this.currentPage$ = this.route.queryParamMap.pipe(\r\n            map(qpm => qpm.get('page')),\r\n            map(page => (!page ? 1 : +page)),\r\n            distinctUntilChanged(),\r\n        );\r\n        this.itemsPerPage$ = this.route.queryParamMap.pipe(\r\n            map(qpm => qpm.get('perPage')),\r\n            map(perPage => (!perPage ? this.defaults.take : +perPage)),\r\n            distinctUntilChanged(),\r\n        );\r\n\r\n        combineLatest(this.currentPage$, this.itemsPerPage$, this.refresh$)\r\n            .pipe(takeUntil(this.destroy$))\r\n            .subscribe(fetchPage);\r\n    }\r\n\r\n    /** @internal */\r\n    ngOnDestroy() {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n        this.listQuery.completed$.next();\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Sets the current page number in the url.\r\n     */\r\n    setPageNumber(page: number) {\r\n        this.setQueryParam('page', page, { replaceUrl: true });\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Sets the number of items per page in the url.\r\n     */\r\n    setItemsPerPage(perPage: number) {\r\n        this.setQueryParam('perPage', perPage, { replaceUrl: true });\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Re-fetch the current page of results.\r\n     */\r\n    refresh() {\r\n        this.refresh$.next(undefined);\r\n    }\r\n\r\n    protected setQueryParam(\r\n        hash: { [key: string]: any },\r\n        options?: { replaceUrl?: boolean; queryParamsHandling?: QueryParamsHandling },\r\n    );\r\n    protected setQueryParam(\r\n        key: string,\r\n        value: any,\r\n        options?: { replaceUrl?: boolean; queryParamsHandling?: QueryParamsHandling },\r\n    );\r\n    protected setQueryParam(\r\n        keyOrHash: string | { [key: string]: any },\r\n        valueOrOptions?: any,\r\n        maybeOptions?: { replaceUrl?: boolean; queryParamsHandling?: QueryParamsHandling },\r\n    ) {\r\n        const paramsObject = typeof keyOrHash === 'string' ? { [keyOrHash]: valueOrOptions } : keyOrHash;\r\n        const options = (typeof keyOrHash === 'string' ? maybeOptions : valueOrOptions) ?? {};\r\n        this.router.navigate(['./'], {\r\n            queryParams: typeof keyOrHash === 'string' ? { [keyOrHash]: valueOrOptions } : keyOrHash,\r\n            relativeTo: this.route,\r\n            queryParamsHandling: 'merge',\r\n            ...options,\r\n        });\r\n    }\r\n}\r\n"]}