@deenruv/admin-ui 1.0.0

package/esm2022/catalog/public_api.mjs

@@ -0,0 +1,50 @@
+// 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/assign-products-to-channel-dialog/assign-products-to-channel-dialog.component';
+export * from './components/bulk-add-facet-values-dialog/bulk-add-facet-values-dialog.component';
+export * from './components/bulk-add-facet-values-dialog/bulk-add-facet-values-dialog.graphql';
+export * from './components/collection-contents/collection-contents.component';
+export * from './components/collection-data-table/collection-data-table.component';
+export * from './components/collection-detail/collection-detail.component';
+export * from './components/collection-list/collection-breadcrumb.pipe';
+export * from './components/collection-list/collection-list-bulk-actions';
+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/create-facet-value-dialog/create-facet-value-dialog.component';
+export * from './components/create-product-option-group-dialog/create-product-option-group-dialog.component';
+export * from './components/create-product-variant-dialog/create-product-variant-dialog.component';
+export * from './components/facet-detail/facet-detail.component';
+export * from './components/facet-list/facet-list-bulk-actions';
+export * from './components/facet-list/facet-list.component';
+export * from './components/generate-product-variants/generate-product-variants.component';
+export * from './components/move-collections-dialog/move-collections-dialog.component';
+export * from './components/option-value-input/option-value-input.component';
+export * from './components/product-detail/product-detail.component';
+export * from './components/product-list/product-list-bulk-actions';
+export * from './components/product-list/product-list.component';
+export * from './components/product-list/product-list.graphql';
+export * from './components/product-options-editor/product-options-editor.component';
+export * from './components/product-variant-detail/product-variant-detail.component';
+export * from './components/product-variant-detail/product-variant-detail.graphql';
+export * from './components/product-variant-list/product-variant-list-bulk-actions';
+export * from './components/product-variant-list/product-variant-list.component';
+export * from './components/product-variant-list/product-variant-list.graphql';
+export * from './components/product-variant-quick-jump/product-variant-quick-jump.component';
+export * from './components/product-variants-editor/product-variants-editor.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 './components/variant-price-strategy-detail/variant-price-strategy-detail.component';
+export * from './providers/product-detail/product-detail.service';
+export * from './providers/product-detail/replace-last';
+export * from './providers/routing/product-variants-resolver';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/app.component.mjs

@@ -0,0 +1,94 @@
+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 "@angular/router";
+import * as i5 from "./components/overlay-host/overlay-host.component";
+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);
+            this._document?.body.setAttribute('cds-theme', theme === 'dark' ? 'dark' : 'light');
+        });
+        // 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(() => this.dataService.client.uiState().mapStream(data => data.uiState.contentLanguage)), switchMap(contentLang => 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();
+                }
+            },
+        });
+        this.dataService.client.userStatus().stream$.subscribe(({ userStatus }) => {
+            this.localStorageService.setAdminId(userStatus.administratorId);
+            if (userStatus.administratorId) {
+                const theme = this.localStorageService.get('activeTheme');
+                if (theme) {
+                    this.dataService.client.setUiTheme(theme).subscribe(() => {
+                        this.localStorageService.set('activeTheme', theme);
+                    });
+                }
+                const activeChannelToken = this.localStorageService.get('activeChannelToken');
+                if (activeChannelToken) {
+                    const activeChannel = userStatus.channels.find(c => c.token === activeChannelToken);
+                    if (activeChannel) {
+                        this.dataService.client.setActiveChannel(activeChannel.id).subscribe();
+                    }
+                }
+            }
+        });
+        if (isDevMode()) {
+            // eslint-disable-next-line no-console
+            console.log(`%cDeenruv 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();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppComponent, deps: [{ token: i1.DataService }, { token: i2.ServerConfigService }, { token: i3.LocalStorageService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AppComponent, selector: "vdr-root", host: { listeners: { "window:keydown": "handleGlobalHotkeys($event)" } }, ngImport: i0, template: "<div class=\"progress loop\" [class.visible]=\"loading$ | async\"></div>\n<router-outlet></router-outlet>\n<vdr-overlay-host></vdr-overlay-host>\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"], dependencies: [{ kind: "directive", type: i4.RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { kind: "component", type: i5.OverlayHostComponent, selector: "vdr-overlay-host" }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-root', template: "<div class=\"progress loop\" [class.visible]=\"loading$ | async\"></div>\n<router-outlet></router-outlet>\n<vdr-overlay-host></vdr-overlay-host>\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: () => [{ 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';\nimport { Component, HostListener, Inject, isDevMode, OnInit } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { filter, map, switchMap } from 'rxjs/operators';\n\nimport { DataService } from './data/providers/data.service';\nimport { ServerConfigService } from './data/server-config';\nimport { LocalStorageService } from './providers/local-storage/local-storage.service';\n\n@Component({\n    selector: 'vdr-root',\n    templateUrl: './app.component.html',\n    styleUrls: ['./app.component.scss'],\n})\nexport class AppComponent implements OnInit {\n    loading$: Observable<boolean>;\n    private _document?: Document;\n\n    constructor(\n        private dataService: DataService,\n        private serverConfigService: ServerConfigService,\n        private localStorageService: LocalStorageService,\n        @Inject(DOCUMENT) private document?: any,\n    ) {\n        this._document = document;\n    }\n\n    ngOnInit() {\n        this.loading$ = this.dataService.client\n            .getNetworkStatus()\n            .stream$.pipe(map(data => 0 < data.networkStatus.inFlightRequests));\n\n        this.dataService.client\n            .uiState()\n            .mapStream(data => data.uiState.theme)\n            .subscribe(theme => {\n                this._document?.body.setAttribute('data-theme', theme);\n                this._document?.body.setAttribute('cds-theme', theme === 'dark' ? 'dark' : 'light');\n            });\n\n        // Once logged in, keep the localStorage \"contentLanguageCode\" in sync with the\n        // uiState. Also perform a check to ensure that the current contentLanguage is\n        // one of the availableLanguages per GlobalSettings.\n        this.dataService.client\n            .userStatus()\n            .mapStream(({ userStatus }) => userStatus.isLoggedIn)\n            .pipe(\n                filter(loggedIn => loggedIn === true),\n                switchMap(() =>\n                    this.dataService.client.uiState().mapStream(data => data.uiState.contentLanguage),\n                ),\n                switchMap(contentLang =>\n                    this.serverConfigService\n                        .getAvailableLanguages()\n                        .pipe(map(available => [contentLang, available] as const)),\n                ),\n            )\n            .subscribe({\n                next: ([contentLanguage, availableLanguages]) => {\n                    this.localStorageService.set('contentLanguageCode', contentLanguage);\n                    if (availableLanguages.length && !availableLanguages.includes(contentLanguage)) {\n                        this.dataService.client.setContentLanguage(availableLanguages[0]).subscribe();\n                    }\n                },\n            });\n\n        this.dataService.client.userStatus().stream$.subscribe(({ userStatus }) => {\n            this.localStorageService.setAdminId(userStatus.administratorId);\n\n            if (userStatus.administratorId) {\n                const theme = this.localStorageService.get('activeTheme');\n                if (theme) {\n                    this.dataService.client.setUiTheme(theme).subscribe(() => {\n                        this.localStorageService.set('activeTheme', theme);\n                    });\n                }\n                const activeChannelToken = this.localStorageService.get('activeChannelToken');\n                if (activeChannelToken) {\n                    const activeChannel = userStatus.channels.find(c => c.token === activeChannelToken);\n                    if (activeChannel) {\n                        this.dataService.client.setActiveChannel(activeChannel.id).subscribe();\n                    }\n                }\n            }\n        });\n\n        if (isDevMode()) {\n            // eslint-disable-next-line no-console\n            console.log(\n                `%cDeenruv Admin UI: Press \"ctrl/cmd + u\" to view UI extension points`,\n                `color: #17C1FF; font-weight: bold;`,\n            );\n        }\n    }\n\n    @HostListener('window:keydown', ['$event'])\n    handleGlobalHotkeys(event: KeyboardEvent) {\n        if ((event.ctrlKey === true || event.metaKey === true) && event.key === 'u') {\n            event.preventDefault();\n            if (isDevMode()) {\n                this.dataService.client\n                    .uiState()\n                    .single$.pipe(\n                        switchMap(({ uiState }) =>\n                            this.dataService.client.setDisplayUiExtensionPoints(\n                                !uiState.displayUiExtensionPoints,\n                            ),\n                        ),\n                    )\n                    .subscribe();\n            }\n        }\n    }\n}\n","<div class=\"progress loop\" [class.visible]=\"loading$ | async\"></div>\n<router-outlet></router-outlet>\n<vdr-overlay-host></vdr-overlay-host>\n"]}

package/esm2022/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 {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppComponentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: AppComponentModule, declarations: [AppComponent], imports: [SharedModule, CoreModule], exports: [AppComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppComponentModule, imports: [SharedModule, CoreModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppComponentModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [SharedModule, CoreModule],
+                    declarations: [AppComponent],
+                    exports: [AppComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmNvbXBvbmVudC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2FwcC5jb21wb25lbnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQU90RCxNQUFNLE9BQU8sa0JBQWtCOytHQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixpQkFIWixZQUFZLGFBRGpCLFlBQVksRUFBRSxVQUFVLGFBRXhCLFlBQVk7Z0hBRWIsa0JBQWtCLFlBSmpCLFlBQVksRUFBRSxVQUFVOzs0RkFJekIsa0JBQWtCO2tCQUw5QixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxVQUFVLENBQUM7b0JBQ25DLFlBQVksRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDNUIsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO2lCQUMxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IEFwcENvbXBvbmVudCB9IGZyb20gJy4vYXBwLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDb3JlTW9kdWxlIH0gZnJvbSAnLi9jb3JlLm1vZHVsZSc7XG5pbXBvcnQgeyBTaGFyZWRNb2R1bGUgfSBmcm9tICcuL3NoYXJlZC9zaGFyZWQubW9kdWxlJztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbU2hhcmVkTW9kdWxlLCBDb3JlTW9kdWxlXSxcbiAgICBkZWNsYXJhdGlvbnM6IFtBcHBDb21wb25lbnRdLFxuICAgIGV4cG9ydHM6IFtBcHBDb21wb25lbnRdLFxufSlcbmV4cG9ydCBjbGFzcyBBcHBDb21wb25lbnRNb2R1bGUge31cbiJdfQ==

package/esm2022/core/app.config.mjs

@@ -0,0 +1,11 @@
+let deenruvUiConfig;
+export async function loadAppConfig() {
+    deenruvUiConfig = await fetch('./deenruv-ui-config.json').then(res => res.json());
+}
+export function getAppConfig() {
+    if (!deenruvUiConfig) {
+        throw new Error(`deenruv ui config not loaded`);
+    }
+    return deenruvUiConfig;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvYXBwLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxJQUFJLGVBQTBDLENBQUM7QUFFL0MsTUFBTSxDQUFDLEtBQUssVUFBVSxhQUFhO0lBQy9CLGVBQWUsR0FBRyxNQUFNLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0FBQ3RGLENBQUM7QUFFRCxNQUFNLFVBQVUsWUFBWTtJQUN4QixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDbkIsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO0lBQ3BELENBQUM7SUFDRCxPQUFPLGVBQWUsQ0FBQztBQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWRtaW5VaUNvbmZpZyB9IGZyb20gJ0BkZWVucnV2L2NvbW1vbi9saWIvc2hhcmVkLXR5cGVzJztcblxubGV0IGRlZW5ydXZVaUNvbmZpZzogQWRtaW5VaUNvbmZpZyB8IHVuZGVmaW5lZDtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGxvYWRBcHBDb25maWcoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgZGVlbnJ1dlVpQ29uZmlnID0gYXdhaXQgZmV0Y2goJy4vZGVlbnJ1di11aS1jb25maWcuanNvbicpLnRoZW4ocmVzID0+IHJlcy5qc29uKCkpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0QXBwQ29uZmlnKCk6IEFkbWluVWlDb25maWcge1xuICAgIGlmICghZGVlbnJ1dlVpQ29uZmlnKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihgZGVlbnJ1diB1aSBjb25maWcgbm90IGxvYWRlZGApO1xuICAgIH1cbiAgICByZXR1cm4gZGVlbnJ1dlVpQ29uZmlnO1xufVxuIl19

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

@@ -0,0 +1,208 @@
+import { inject } from '@angular/core';
+import { ActivatedRoute, ActivationStart, Router } from '@angular/router';
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+import { combineLatest, of, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map, shareReplay, switchMap, takeUntil, tap } from 'rxjs/operators';
+import { DataService } from '../data/providers/data.service';
+import { ServerConfigService } from '../data/server-config';
+import { PermissionsService } from '../providers/permissions/permissions.service';
+/**
+ * @description
+ * A base class for entity detail views. It should be used in conjunction with the
+ * {@link BaseEntityResolver}.
+ *
+ * @example
+ * ```ts
+ * \@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, permissionsService) {
+        this.route = route;
+        this.router = router;
+        this.serverConfigService = serverConfigService;
+        this.dataService = dataService;
+        this.permissionsService = permissionsService;
+        this.destroy$ = new Subject();
+    }
+    init() {
+        this.entity$ = this.route.data.pipe(switchMap(data => data.entity.pipe(takeUntil(this.destroy$))), filter(notNullOrUndefined), tap(entity => (this.id = entity.id)), shareReplay(1));
+        this.isNew$ = this.entity$.pipe(map(entity => !entity?.id), shareReplay(1));
+        this.setUpStreams();
+    }
+    setUpStreams() {
+        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(), tap(val => (this.languageCode = val)), shareReplay(1));
+        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();
+        combineLatest(this.entity$, this.languageCode$)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(([entity, languageCode]) => {
+            if (entity) {
+                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' || fieldDef.type === 'localeText'
+                ? currentTranslation?.customFields?.[key]
+                : entity.customFields?.[key];
+            const control = formGroup?.get(key);
+            if (control) {
+                control.patchValue(value);
+            }
+        }
+    }
+    getCustomFieldConfig(key) {
+        return this.serverConfigService.getCustomFieldsFor(key).filter(f => {
+            if (f.requiresPermission?.length) {
+                return this.permissionsService.userHasPermissions(f.requiresPermission);
+            }
+            return true;
+        });
+    }
+    setQueryParam(key, value) {
+        this.router.navigate([
+            './',
+            {
+                ...this.route.snapshot.params,
+                [key]: value,
+            },
+        ], {
+            relativeTo: this.route,
+            queryParamsHandling: 'merge',
+        });
+    }
+}
+/**
+ * @description
+ * A version of the {@link BaseDetailComponent} which is designed to be used with a
+ * [TypedDocumentNode](https://the-guild.dev/graphql/codegen/plugins/typescript/typed-document-node).
+ *
+ * @docsCategory list-detail-views
+ */
+export class TypedBaseDetailComponent extends BaseDetailComponent {
+    constructor() {
+        super(inject(ActivatedRoute), inject(Router), inject(ServerConfigService), inject(DataService), inject(PermissionsService));
+    }
+    init() {
+        this.entity$ = this.route.data.pipe(switchMap(data => data.detail.entity.pipe(takeUntil(this.destroy$))), filter(notNullOrUndefined), tap(entity => {
+            this.id = entity.id;
+            this.entity = entity;
+        }), shareReplay(1));
+        this.result$ = this.route.data.pipe(map(data => data.detail.result), shareReplay(1));
+        this.isNew$ = this.route.data.pipe(switchMap(data => data.detail.entity), map(entity => !entity), shareReplay(1));
+        this.setUpStreams();
+    }
+}
+/**
+ * @description
+ * A helper function for creating tabs that point to a {@link TypedBaseDetailComponent}. This takes
+ * care of the route resolver parts so that the detail component automatically has access to the
+ * correct resolved detail data.
+ *
+ * @example
+ * ```ts
+ * \@NgModule({
+ *   imports: [ReviewsSharedModule],
+ *   declarations: [/* ... *\/],
+ *   providers: [
+ *     registerPageTab({
+ *       location: 'product-detail',
+ *       tab: 'Specs',
+ *       route: 'specs',
+ *       component: detailComponentWithResolver({
+ *         component: ProductSpecDetailComponent,
+ *         query: GetProductSpecsDocument,
+ *         entityKey: 'spec',
+ *       }),
+ *     }),
+ *   ],
+ * })
+ * export class ProductSpecsUiExtensionModule {}
+ * ```
+ * @docsCategory list-detail-views
+ */
+export function detailComponentWithResolver(config) {
+    return {
+        resolveFn: createBaseDetailResolveFn(config),
+        breadcrumbFn: (result) => config.getBreadcrumbs?.(result) ?? [],
+        component: config.component,
+    };
+}
+export function createBaseDetailResolveFn(config) {
+    return route => {
+        const router = inject(Router);
+        const dataService = inject(DataService);
+        const id = route.paramMap.get('id');
+        // Complete the entity stream upon navigating away
+        const navigateAway$ = router.events.pipe(filter(event => event instanceof ActivationStart));
+        if (id == null) {
+            throw new Error('No id found in route');
+        }
+        if (id === 'create') {
+            return of({ entity: of(null) });
+        }
+        else {
+            const result$ = dataService
+                .query(config.query, { id, ...(config.variables ?? {}) })
+                .refetchOnChannelChange()
+                .stream$.pipe(takeUntil(navigateAway$), shareReplay(1));
+            const entity$ = result$.pipe(map(result => result[config.entityKey]));
+            const entityStream$ = entity$.pipe(filter(notNullOrUndefined));
+            return result$.pipe(map(result => ({
+                entity: entityStream$,
+                result,
+            })));
+        }
+    };
+}
+//# 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":"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","sourcesContent":["import { inject, Type } from '@angular/core';\nimport { AbstractControl, UntypedFormGroup } from '@angular/forms';\nimport { ActivatedRoute, ActivationStart, ResolveFn, Router } from '@angular/router';\nimport { ResultOf, TypedDocumentNode } from '@graphql-typed-document-node/core';\nimport { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';\nimport { combineLatest, Observable, of, Subject } from 'rxjs';\nimport { distinctUntilChanged, filter, map, shareReplay, switchMap, takeUntil, tap } from 'rxjs/operators';\n\nimport { DataService } from '../data/providers/data.service';\nimport { ServerConfigService } from '../data/server-config';\nimport { BreadcrumbValue } from '../providers/breadcrumb/breadcrumb.service';\nimport { PermissionsService } from '../providers/permissions/permissions.service';\n\nimport { DeactivateAware } from './deactivate-aware';\nimport { CustomFieldConfig, CustomFields, LanguageCode } from './generated-types';\nimport { TranslationOf } from './utilities/find-translation';\n\n/**\n * @description\n * A base class for entity detail views. It should be used in conjunction with the\n * {@link BaseEntityResolver}.\n *\n * @example\n * ```ts\n * \\@Component({\n *   selector: 'app-my-entity',\n *   templateUrl: './my-entity.component.html',\n *   styleUrls: ['./my-entity.component.scss'],\n *   changeDetection: ChangeDetectionStrategy.OnPush,\n * })\n * export class GlobalSettingsComponent extends BaseDetailComponent<MyEntityFragment> implements OnInit {\n *   detailForm: FormGroup;\n *\n *   constructor(\n *     router: Router,\n *     route: ActivatedRoute,\n *     serverConfigService: ServerConfigService,\n *     protected dataService: DataService,\n *     private formBuilder: FormBuilder,\n *   ) {\n *     super(route, router, serverConfigService, dataService);\n *     this.detailForm = this.formBuilder.group({\n *       name: [''],\n *     });\n *   }\n *\n *   protected setFormValues(entity: MyEntityFragment, languageCode: LanguageCode): void {\n *     this.detailForm.patchValue({\n *       name: entity.name,\n *     });\n *   }\n * }\n * ```\n *\n * @docsCategory list-detail-views\n */\nexport abstract class BaseDetailComponent<Entity extends { id: string; updatedAt?: string }>\n    implements DeactivateAware\n{\n    entity$: Observable<Entity>;\n    availableLanguages$: Observable<LanguageCode[]>;\n    languageCode$: Observable<LanguageCode>;\n    languageCode: LanguageCode;\n    isNew$: Observable<boolean>;\n    id: string;\n    abstract detailForm: UntypedFormGroup;\n    protected destroy$ = new Subject<void>();\n\n    protected constructor(\n        protected route: ActivatedRoute,\n        protected router: Router,\n        protected serverConfigService: ServerConfigService,\n        protected dataService: DataService,\n        protected permissionsService: PermissionsService,\n    ) {}\n\n    init() {\n        this.entity$ = this.route.data.pipe(\n            switchMap(data => (data.entity as Observable<Entity>).pipe(takeUntil(this.destroy$))),\n            filter(notNullOrUndefined),\n            tap(entity => (this.id = entity.id)),\n            shareReplay(1),\n        );\n        this.isNew$ = this.entity$.pipe(\n            map(entity => !entity?.id),\n            shareReplay(1),\n        );\n        this.setUpStreams();\n    }\n\n    protected setUpStreams() {\n        this.languageCode$ = this.route.paramMap.pipe(\n            map(paramMap => paramMap.get('lang')),\n            switchMap(lang => {\n                if (lang) {\n                    return of(lang as LanguageCode);\n                } else {\n                    return this.dataService.client.uiState().mapSingle(data => data.uiState.contentLanguage);\n                }\n            }),\n            distinctUntilChanged(),\n            tap(val => (this.languageCode = val)),\n            shareReplay(1),\n        );\n\n        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();\n\n        combineLatest(this.entity$, this.languageCode$)\n            .pipe(takeUntil(this.destroy$))\n            .subscribe(([entity, languageCode]) => {\n                if (entity) {\n                    this.setFormValues(entity, languageCode);\n                }\n                this.detailForm.markAsPristine();\n            });\n    }\n\n    destroy() {\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    setLanguage(code: LanguageCode) {\n        this.setQueryParam('lang', code);\n        this.dataService.client.setContentLanguage(code).subscribe();\n    }\n\n    canDeactivate(): boolean {\n        return this.detailForm && this.detailForm.pristine;\n    }\n\n    protected abstract setFormValues(entity: Entity, languageCode: LanguageCode): void;\n\n    protected setCustomFieldFormValues<T = Entity>(\n        customFields: CustomFieldConfig[],\n        formGroup: AbstractControl | null,\n        entity: T,\n        currentTranslation?: TranslationOf<T>,\n    ) {\n        for (const fieldDef of customFields) {\n            const key = fieldDef.name;\n            const value =\n                fieldDef.type === 'localeString' || fieldDef.type === 'localeText'\n                    ? (currentTranslation as any)?.customFields?.[key]\n                    : (entity as any).customFields?.[key];\n            const control = formGroup?.get(key);\n            if (control) {\n                control.patchValue(value);\n            }\n        }\n    }\n\n    protected getCustomFieldConfig(key: Exclude<keyof CustomFields, '__typename'>): CustomFieldConfig[] {\n        return this.serverConfigService.getCustomFieldsFor(key).filter(f => {\n            if (f.requiresPermission?.length) {\n                return this.permissionsService.userHasPermissions(f.requiresPermission);\n            }\n            return true;\n        });\n    }\n\n    protected setQueryParam(key: string, value: any) {\n        this.router.navigate(\n            [\n                './',\n                {\n                    ...this.route.snapshot.params,\n                    [key]: value,\n                },\n            ],\n            {\n                relativeTo: this.route,\n                queryParamsHandling: 'merge',\n            },\n        );\n    }\n}\n\n/**\n * @description\n * A version of the {@link BaseDetailComponent} which is designed to be used with a\n * [TypedDocumentNode](https://the-guild.dev/graphql/codegen/plugins/typescript/typed-document-node).\n *\n * @docsCategory list-detail-views\n */\nexport abstract class TypedBaseDetailComponent<\n    T extends TypedDocumentNode<any, any>,\n    Field extends keyof ResultOf<T>,\n> extends BaseDetailComponent<NonNullable<ResultOf<T>[Field]>> {\n    protected result$: Observable<ResultOf<T>>;\n    protected entity: ResultOf<T>[Field];\n\n    protected constructor() {\n        super(\n            inject(ActivatedRoute),\n            inject(Router),\n            inject(ServerConfigService),\n            inject(DataService),\n            inject(PermissionsService),\n        );\n    }\n\n    override init() {\n        this.entity$ = this.route.data.pipe(\n            switchMap(data =>\n                (data.detail.entity as Observable<ResultOf<T>[Field]>).pipe(takeUntil(this.destroy$)),\n            ),\n            filter(notNullOrUndefined),\n            tap(entity => {\n                this.id = entity.id;\n                this.entity = entity;\n            }),\n            shareReplay(1),\n        );\n        this.result$ = this.route.data.pipe(\n            map(data => data.detail.result),\n            shareReplay(1),\n        );\n        this.isNew$ = this.route.data.pipe(\n            switchMap(data => data.detail.entity),\n            map(entity => !entity),\n            shareReplay(1),\n        );\n        this.setUpStreams();\n    }\n}\n\n/**\n * @description\n * A helper function for creating tabs that point to a {@link TypedBaseDetailComponent}. This takes\n * care of the route resolver parts so that the detail component automatically has access to the\n * correct resolved detail data.\n *\n * @example\n * ```ts\n * \\@NgModule({\n *   imports: [ReviewsSharedModule],\n *   declarations: [/* ... *\\/],\n *   providers: [\n *     registerPageTab({\n *       location: 'product-detail',\n *       tab: 'Specs',\n *       route: 'specs',\n *       component: detailComponentWithResolver({\n *         component: ProductSpecDetailComponent,\n *         query: GetProductSpecsDocument,\n *         entityKey: 'spec',\n *       }),\n *     }),\n *   ],\n * })\n * export class ProductSpecsUiExtensionModule {}\n * ```\n * @docsCategory list-detail-views\n */\nexport function detailComponentWithResolver<\n    T extends TypedDocumentNode<any, { id: string }>,\n    Field extends keyof ResultOf<T>,\n    R extends Field,\n>(config: {\n    component: Type<TypedBaseDetailComponent<T, Field>>;\n    query: T;\n    entityKey: R;\n    getBreadcrumbs?: (entity: ResultOf<T>[R]) => BreadcrumbValue;\n    variables?: T extends TypedDocumentNode<any, infer V> ? Omit<V, 'id'> : never;\n}) {\n    return {\n        resolveFn: createBaseDetailResolveFn(config),\n        breadcrumbFn: (result: any) => config.getBreadcrumbs?.(result) ?? ([] as BreadcrumbValue[]),\n        component: config.component,\n    };\n}\n\nexport function createBaseDetailResolveFn<\n    T extends TypedDocumentNode<any, { id: string }>,\n    Field extends keyof ResultOf<T>,\n    R extends Field,\n>(config: {\n    query: T;\n    entityKey: R | string;\n    variables?: T extends TypedDocumentNode<any, infer V> ? Omit<V, 'id'> : never;\n}): ResolveFn<{\n    entity: Observable<ResultOf<T>[Field] | null>;\n    result?: ResultOf<T>;\n}> {\n    return route => {\n        const router = inject(Router);\n        const dataService = inject(DataService);\n        const id = route.paramMap.get('id');\n\n        // Complete the entity stream upon navigating away\n        const navigateAway$ = router.events.pipe(filter(event => event instanceof ActivationStart));\n\n        if (id == null) {\n            throw new Error('No id found in route');\n        }\n        if (id === 'create') {\n            return of({ entity: of(null) });\n        } else {\n            const result$ = dataService\n                .query(config.query, { id, ...(config.variables ?? {}) })\n                .refetchOnChannelChange()\n                .stream$.pipe(takeUntil(navigateAway$), shareReplay(1));\n            const entity$ = result$.pipe(map(result => result[config.entityKey]));\n            const entityStream$ = entity$.pipe(filter(notNullOrUndefined));\n            return result$.pipe(\n                map(result => ({\n                    entity: entityStream$,\n                    result,\n                })),\n            );\n        }\n    };\n}\n"]}

package/esm2022/core/common/base-entity-resolver.mjs

@@ -0,0 +1,60 @@
+import { ActivationStart, } from '@angular/router';
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+import { of } from 'rxjs';
+import { filter, map, shareReplay, take, takeUntil } from 'rxjs/operators';
+export function createResolveData(resolver) {
+    return {
+        entity: resolver,
+    };
+}
+/**
+ * @description
+ * A base resolver for an entity detail route. Resolves to an observable of the given entity, or a "blank"
+ * version if the route id equals "create". Should be used together with details views which extend the
+ * {@link BaseDetailComponent}.
+ *
+ * @example
+ * ```ts
+ * \@Injectable({
+ *   providedIn: 'root',
+ * })
+ * export class MyEntityResolver extends BaseEntityResolver<MyEntityFragment> {
+ *   constructor(router: Router, dataService: DataService) {
+ *     super(
+ *       router,
+ *       {
+ *         __typename: 'MyEntity',
+ *         id: '',
+ *         createdAt: '',
+ *         updatedAt: '',
+ *         name: '',
+ *       },
+ *       id => dataService.query(GET_MY_ENTITY, { id }).mapStream(data => data.myEntity),
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * @docsCategory list-detail-views
+ */
+export class BaseEntityResolver {
+    constructor(router, emptyEntity, entityStream) {
+        this.router = router;
+        this.emptyEntity = emptyEntity;
+        this.entityStream = entityStream;
+    }
+    /** @internal */
+    resolve(route, state) {
+        const id = route.paramMap.get('id');
+        // Complete the entity stream upon navigating away
+        const navigateAway$ = this.router.events.pipe(filter(event => event instanceof ActivationStart));
+        if (id === 'create') {
+            return of(of(this.emptyEntity));
+        }
+        else {
+            const stream = this.entityStream(id || '').pipe(takeUntil(navigateAway$), filter(notNullOrUndefined), shareReplay(1));
+            return stream.pipe(take(1), map(() => stream));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1lbnRpdHktcmVzb2x2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2NvbW1vbi9iYXNlLWVudGl0eS1yZXNvbHZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBRUgsZUFBZSxHQUlsQixNQUFNLGlCQUFpQixDQUFDO0FBRXpCLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3RFLE9BQU8sRUFBYyxFQUFFLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDdEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQU0zRSxNQUFNLFVBQVUsaUJBQWlCLENBQzdCLFFBQWlCO0lBRWpCLE9BQU87UUFDSCxNQUFNLEVBQUUsUUFBUTtLQUNuQixDQUFDO0FBQ04sQ0FBQztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTZCRztBQUNILE1BQU0sT0FBTyxrQkFBa0I7SUFDM0IsWUFDYyxNQUFjLEVBQ1AsV0FBYyxFQUN2QixZQUE4RDtRQUY1RCxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQ1AsZ0JBQVcsR0FBWCxXQUFXLENBQUc7UUFDdkIsaUJBQVksR0FBWixZQUFZLENBQWtEO0lBQ3ZFLENBQUM7SUFFSixnQkFBZ0I7SUFDaEIsT0FBTyxDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDN0QsTUFBTSxFQUFFLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFcEMsa0RBQWtEO1FBQ2xELE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxLQUFLLFlBQVksZUFBZSxDQUFDLENBQUMsQ0FBQztRQUVqRyxJQUFJLEVBQUUsS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUNsQixPQUFPLEVBQUUsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7UUFDcEMsQ0FBQzthQUFNLENBQUM7WUFDSixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQzNDLFNBQVMsQ0FBQyxhQUFhLENBQUMsRUFDeEIsTUFBTSxDQUFDLGtCQUFrQixDQUFDLEVBQzFCLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FDakIsQ0FBQztZQUVGLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FDZCxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQ1AsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUNwQixDQUFDO1FBQ04sQ0FBQztJQUNMLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gICAgQWN0aXZhdGVkUm91dGVTbmFwc2hvdCxcbiAgICBBY3RpdmF0aW9uU3RhcnQsXG4gICAgUmVzb2x2ZURhdGEsXG4gICAgUm91dGVyLFxuICAgIFJvdXRlclN0YXRlU25hcHNob3QsXG59IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBUeXBlIH0gZnJvbSAnQGRlZW5ydXYvY29tbW9uL2xpYi9zaGFyZWQtdHlwZXMnO1xuaW1wb3J0IHsgbm90TnVsbE9yVW5kZWZpbmVkIH0gZnJvbSAnQGRlZW5ydXYvY29tbW9uL2xpYi9zaGFyZWQtdXRpbHMnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IGZpbHRlciwgbWFwLCBzaGFyZVJlcGxheSwgdGFrZSwgdGFrZVVudGlsIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEVudGl0eVJlc29sdmVEYXRhPFI+IGV4dGVuZHMgUmVzb2x2ZURhdGEge1xuICAgIGVudGl0eTogVHlwZTxCYXNlRW50aXR5UmVzb2x2ZXI8Uj4+O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlUmVzb2x2ZURhdGE8VCBleHRlbmRzIEJhc2VFbnRpdHlSZXNvbHZlcjxSPiwgUj4oXG4gICAgcmVzb2x2ZXI6IFR5cGU8VD4sXG4pOiBFbnRpdHlSZXNvbHZlRGF0YTxSPiB7XG4gICAgcmV0dXJuIHtcbiAgICAgICAgZW50aXR5OiByZXNvbHZlcixcbiAgICB9O1xufVxuXG4vKipcbiAqIEBkZXNjcmlwdGlvblxuICogQSBiYXNlIHJlc29sdmVyIGZvciBhbiBlbnRpdHkgZGV0YWlsIHJvdXRlLiBSZXNvbHZlcyB0byBhbiBvYnNlcnZhYmxlIG9mIHRoZSBnaXZlbiBlbnRpdHksIG9yIGEgXCJibGFua1wiXG4gKiB2ZXJzaW9uIGlmIHRoZSByb3V0ZSBpZCBlcXVhbHMgXCJjcmVhdGVcIi4gU2hvdWxkIGJlIHVzZWQgdG9nZXRoZXIgd2l0aCBkZXRhaWxzIHZpZXdzIHdoaWNoIGV4dGVuZCB0aGVcbiAqIHtAbGluayBCYXNlRGV0YWlsQ29tcG9uZW50fS5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIFxcQEluamVjdGFibGUoe1xuICogICBwcm92aWRlZEluOiAncm9vdCcsXG4gKiB9KVxuICogZXhwb3J0IGNsYXNzIE15RW50aXR5UmVzb2x2ZXIgZXh0ZW5kcyBCYXNlRW50aXR5UmVzb2x2ZXI8TXlFbnRpdHlGcmFnbWVudD4ge1xuICogICBjb25zdHJ1Y3Rvcihyb3V0ZXI6IFJvdXRlciwgZGF0YVNlcnZpY2U6IERhdGFTZXJ2aWNlKSB7XG4gKiAgICAgc3VwZXIoXG4gKiAgICAgICByb3V0ZXIsXG4gKiAgICAgICB7XG4gKiAgICAgICAgIF9fdHlwZW5hbWU6ICdNeUVudGl0eScsXG4gKiAgICAgICAgIGlkOiAnJyxcbiAqICAgICAgICAgY3JlYXRlZEF0OiAnJyxcbiAqICAgICAgICAgdXBkYXRlZEF0OiAnJyxcbiAqICAgICAgICAgbmFtZTogJycsXG4gKiAgICAgICB9LFxuICogICAgICAgaWQgPT4gZGF0YVNlcnZpY2UucXVlcnkoR0VUX01ZX0VOVElUWSwgeyBpZCB9KS5tYXBTdHJlYW0oZGF0YSA9PiBkYXRhLm15RW50aXR5KSxcbiAqICAgICApO1xuICogICB9XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAZG9jc0NhdGVnb3J5IGxpc3QtZGV0YWlsLXZpZXdzXG4gKi9cbmV4cG9ydCBjbGFzcyBCYXNlRW50aXR5UmVzb2x2ZXI8VD4ge1xuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwcm90ZWN0ZWQgcm91dGVyOiBSb3V0ZXIsXG4gICAgICAgIHByaXZhdGUgcmVhZG9ubHkgZW1wdHlFbnRpdHk6IFQsXG4gICAgICAgIHByaXZhdGUgZW50aXR5U3RyZWFtOiAoaWQ6IHN0cmluZykgPT4gT2JzZXJ2YWJsZTxUIHwgbnVsbCB8IHVuZGVmaW5lZD4sXG4gICAgKSB7fVxuXG4gICAgLyoqIEBpbnRlcm5hbCAqL1xuICAgIHJlc29sdmUocm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90KTogT2JzZXJ2YWJsZTxPYnNlcnZhYmxlPFQ+PiB7XG4gICAgICAgIGNvbnN0IGlkID0gcm91dGUucGFyYW1NYXAuZ2V0KCdpZCcpO1xuXG4gICAgICAgIC8vIENvbXBsZXRlIHRoZSBlbnRpdHkgc3RyZWFtIHVwb24gbmF2aWdhdGluZyBhd2F5XG4gICAgICAgIGNvbnN0IG5hdmlnYXRlQXdheSQgPSB0aGlzLnJvdXRlci5ldmVudHMucGlwZShmaWx0ZXIoZXZlbnQgPT4gZXZlbnQgaW5zdGFuY2VvZiBBY3RpdmF0aW9uU3RhcnQpKTtcblxuICAgICAgICBpZiAoaWQgPT09ICdjcmVhdGUnKSB7XG4gICAgICAgICAgICByZXR1cm4gb2Yob2YodGhpcy5lbXB0eUVudGl0eSkpO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgY29uc3Qgc3RyZWFtID0gdGhpcy5lbnRpdHlTdHJlYW0oaWQgfHwgJycpLnBpcGUoXG4gICAgICAgICAgICAgICAgdGFrZVVudGlsKG5hdmlnYXRlQXdheSQpLFxuICAgICAgICAgICAgICAgIGZpbHRlcihub3ROdWxsT3JVbmRlZmluZWQpLFxuICAgICAgICAgICAgICAgIHNoYXJlUmVwbGF5KDEpLFxuICAgICAgICAgICAgKTtcblxuICAgICAgICAgICAgcmV0dXJuIHN0cmVhbS5waXBlKFxuICAgICAgICAgICAgICAgIHRha2UoMSksXG4gICAgICAgICAgICAgICAgbWFwKCgpID0+IHN0cmVhbSksXG4gICAgICAgICAgICApO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19