@vendure/admin-ui 1.7.4 → 1.8.0

package/package/esm2015/core/shared/components/dropdown/dropdown-menu.component.js

@@ -0,0 +1,122 @@
+import { Overlay, } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, Input, ViewChild, ViewContainerRef, } from '@angular/core';
+import { DropdownComponent } from './dropdown.component';
+/**
+ * A dropdown menu modelled on the Clarity Dropdown component (https://v1.clarity.design/dropdowns).
+ *
+ * This was created because the Clarity implementation (at this time) does not handle edge detection. Instead
+ * we make use of the Angular CDK's Overlay module to manage the positioning.
+ *
+ * The API of this component (and its related Components & Directives) are based on the Clarity version,
+ * albeit only a subset which is currently used in this application.
+ */
+export class DropdownMenuComponent {
+    constructor(overlay, viewContainerRef, dropdown) {
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.dropdown = dropdown;
+        this.position = 'bottom-left';
+    }
+    ngOnInit() {
+        this.dropdown.onOpenChange(isOpen => {
+            if (isOpen) {
+                this.overlayRef.attach(this.menuPortal);
+            }
+            else {
+                this.overlayRef.detach();
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this.overlayRef = this.overlay.create({
+            hasBackdrop: true,
+            backdropClass: 'clear-backdrop',
+            positionStrategy: this.getPositionStrategy(),
+            maxHeight: '70vh',
+        });
+        this.menuPortal = new TemplatePortal(this.menuTemplate, this.viewContainerRef);
+        this.backdropClickSub = this.overlayRef.backdropClick().subscribe(() => {
+            this.dropdown.toggleOpen();
+        });
+    }
+    ngOnDestroy() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+        }
+        if (this.backdropClickSub) {
+            this.backdropClickSub.unsubscribe();
+        }
+    }
+    getPositionStrategy() {
+        const position = {
+            ['top-left']: {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+            ['top-right']: {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+            },
+            ['bottom-left']: {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            ['bottom-right']: {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+        };
+        const pos = position[this.position];
+        return this.overlay
+            .position()
+            .flexibleConnectedTo(this.dropdown.trigger)
+            .withPositions([pos, this.invertPosition(pos)])
+            .withViewportMargin(12)
+            .withPush(true);
+    }
+    /** Inverts an overlay position. */
+    invertPosition(pos) {
+        const inverted = Object.assign({}, pos);
+        inverted.originY = pos.originY === 'top' ? 'bottom' : 'top';
+        inverted.overlayY = pos.overlayY === 'top' ? 'bottom' : 'top';
+        return inverted;
+    }
+}
+DropdownMenuComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-dropdown-menu',
+                template: `
+        <ng-template #menu>
+            <div class="dropdown open">
+                <div class="dropdown-menu" [ngClass]="customClasses">
+                    <div class="dropdown-content-wrapper">
+                        <ng-content></ng-content>
+                    </div>
+                </div>
+            </div>
+        </ng-template>
+    `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [".clear-backdrop{background-color:#ff69b4}::ng-deep .dropdown-menu .dropdown-item{display:flex;align-items:center}::ng-deep .dropdown-menu .dropdown-item clr-icon{margin-right:3px}.dropdown.open>.dropdown-menu{position:relative;top:0;height:100%;overflow-y:auto}:host{opacity:1;transition:opacity .3s}\n"]
+            },] }
+];
+DropdownMenuComponent.ctorParameters = () => [
+    { type: Overlay },
+    { type: ViewContainerRef },
+    { type: DropdownComponent }
+];
+DropdownMenuComponent.propDecorators = {
+    position: [{ type: Input, args: ['vdrPosition',] }],
+    customClasses: [{ type: Input }],
+    menuTemplate: [{ type: ViewChild, args: ['menu', { static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-menu.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/components/dropdown/dropdown-menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ConnectedPosition,\r\n    HorizontalConnectionPos,\r\n    Overlay,\r\n    OverlayRef,\r\n    PositionStrategy,\r\n    VerticalConnectionPos,\r\n} from '@angular/cdk/overlay';\r\nimport { TemplatePortal } from '@angular/cdk/portal';\r\nimport {\r\n    AfterViewInit,\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    ContentChild,\r\n    ElementRef,\r\n    Input,\r\n    OnDestroy,\r\n    OnInit,\r\n    TemplateRef,\r\n    ViewChild,\r\n    ViewContainerRef,\r\n} from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\n\r\nimport { DropdownTriggerDirective } from './dropdown-trigger.directive';\r\nimport { DropdownComponent } from './dropdown.component';\r\n\r\nexport type DropdownPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';\r\n\r\n/**\r\n * A dropdown menu modelled on the Clarity Dropdown component (https://v1.clarity.design/dropdowns).\r\n *\r\n * This was created because the Clarity implementation (at this time) does not handle edge detection. Instead\r\n * we make use of the Angular CDK's Overlay module to manage the positioning.\r\n *\r\n * The API of this component (and its related Components & Directives) are based on the Clarity version,\r\n * albeit only a subset which is currently used in this application.\r\n */\r\n@Component({\r\n    selector: 'vdr-dropdown-menu',\r\n    template: `\r\n        <ng-template #menu>\r\n            <div class=\"dropdown open\">\r\n                <div class=\"dropdown-menu\" [ngClass]=\"customClasses\">\r\n                    <div class=\"dropdown-content-wrapper\">\r\n                        <ng-content></ng-content>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-template>\r\n    `,\r\n    styleUrls: ['./dropdown-menu.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class DropdownMenuComponent implements AfterViewInit, OnInit, OnDestroy {\r\n    @Input('vdrPosition') private position: DropdownPosition = 'bottom-left';\r\n    @Input() customClasses: string;\r\n    @ViewChild('menu', { static: true }) private menuTemplate: TemplateRef<any>;\r\n    private menuPortal: TemplatePortal<any>;\r\n    private overlayRef: OverlayRef;\r\n    private backdropClickSub: Subscription;\r\n\r\n    constructor(\r\n        private overlay: Overlay,\r\n        private viewContainerRef: ViewContainerRef,\r\n        private dropdown: DropdownComponent,\r\n    ) {}\r\n\r\n    ngOnInit(): void {\r\n        this.dropdown.onOpenChange(isOpen => {\r\n            if (isOpen) {\r\n                this.overlayRef.attach(this.menuPortal);\r\n            } else {\r\n                this.overlayRef.detach();\r\n            }\r\n        });\r\n    }\r\n\r\n    ngAfterViewInit() {\r\n        this.overlayRef = this.overlay.create({\r\n            hasBackdrop: true,\r\n            backdropClass: 'clear-backdrop',\r\n            positionStrategy: this.getPositionStrategy(),\r\n            maxHeight: '70vh',\r\n        });\r\n        this.menuPortal = new TemplatePortal(this.menuTemplate, this.viewContainerRef);\r\n        this.backdropClickSub = this.overlayRef.backdropClick().subscribe(() => {\r\n            this.dropdown.toggleOpen();\r\n        });\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        if (this.overlayRef) {\r\n            this.overlayRef.dispose();\r\n        }\r\n        if (this.backdropClickSub) {\r\n            this.backdropClickSub.unsubscribe();\r\n        }\r\n    }\r\n\r\n    private getPositionStrategy(): PositionStrategy {\r\n        const position: { [K in DropdownPosition]: ConnectedPosition } = {\r\n            ['top-left']: {\r\n                originX: 'start',\r\n                originY: 'top',\r\n                overlayX: 'start',\r\n                overlayY: 'bottom',\r\n            },\r\n            ['top-right']: {\r\n                originX: 'end',\r\n                originY: 'top',\r\n                overlayX: 'end',\r\n                overlayY: 'bottom',\r\n            },\r\n            ['bottom-left']: {\r\n                originX: 'start',\r\n                originY: 'bottom',\r\n                overlayX: 'start',\r\n                overlayY: 'top',\r\n            },\r\n            ['bottom-right']: {\r\n                originX: 'end',\r\n                originY: 'bottom',\r\n                overlayX: 'end',\r\n                overlayY: 'top',\r\n            },\r\n        };\r\n\r\n        const pos = position[this.position];\r\n\r\n        return this.overlay\r\n            .position()\r\n            .flexibleConnectedTo(this.dropdown.trigger)\r\n            .withPositions([pos, this.invertPosition(pos)])\r\n            .withViewportMargin(12)\r\n            .withPush(true);\r\n    }\r\n\r\n    /** Inverts an overlay position. */\r\n    private invertPosition(pos: ConnectedPosition): ConnectedPosition {\r\n        const inverted = { ...pos };\r\n        inverted.originY = pos.originY === 'top' ? 'bottom' : 'top';\r\n        inverted.overlayY = pos.overlayY === 'top' ? 'bottom' : 'top';\r\n\r\n        return inverted;\r\n    }\r\n}\r\n"]}

package/package/esm2015/core/shared/components/facet-value-selector/facet-value-selector.component.js

@@ -0,0 +1,117 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { NgSelectComponent } from '@ng-select/ng-select';
+import { flattenFacetValues } from '../../../common/utilities/flatten-facet-values';
+import { DataService } from '../../../data/providers/data.service';
+/**
+ * @description
+ * A form control for selecting facet values.
+ *
+ * @example
+ * ```HTML
+ * <vdr-facet-value-selector
+ *   [facets]="facets"
+ *   (selectedValuesChange)="selectedValues = $event"
+ * ></vdr-facet-value-selector>
+ * ```
+ * The `facets` input should be provided from the parent component
+ * like this:
+ *
+ * @example
+ * ```TypeScript
+ * this.facets = this.dataService
+ *   .facet.getAllFacets()
+ *   .mapSingle(data => data.facets.items);
+ * ```
+ * @docsCategory components
+ */
+export class FacetValueSelectorComponent {
+    constructor(dataService) {
+        this.dataService = dataService;
+        this.selectedValuesChange = new EventEmitter();
+        this.readonly = false;
+        this.transformControlValueAccessorValue = value => value;
+        this.facetValues = [];
+        this.disabled = false;
+        this.toSelectorItem = (facetValue) => {
+            return {
+                name: facetValue.name,
+                facetName: facetValue.facet.name,
+                id: facetValue.id,
+                value: facetValue,
+            };
+        };
+    }
+    ngOnInit() {
+        this.facetValues = flattenFacetValues(this.facets).map(this.toSelectorItem);
+    }
+    onChange(selected) {
+        if (this.readonly) {
+            return;
+        }
+        this.selectedValuesChange.emit(selected.map(s => s.value));
+        if (this.onChangeFn) {
+            const transformedValue = this.transformControlValueAccessorValue(selected);
+            this.onChangeFn(transformedValue);
+        }
+    }
+    registerOnChange(fn) {
+        this.onChangeFn = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouchFn = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    focus() {
+        this.ngSelect.focus();
+    }
+    writeValue(obj) {
+        if (typeof obj === 'string') {
+            try {
+                const facetIds = JSON.parse(obj);
+                this.value = facetIds;
+            }
+            catch (err) {
+                // TODO: log error
+                throw err;
+            }
+        }
+        else if (Array.isArray(obj)) {
+            const isIdArray = (input) => input.every(i => typeof i === 'number' || typeof i === 'string');
+            if (isIdArray(obj)) {
+                this.value = obj.map(fv => fv.toString());
+            }
+            else {
+                this.value = obj.map(fv => fv.id);
+            }
+        }
+    }
+}
+FacetValueSelectorComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-facet-value-selector',
+                template: "<ng-select\r\n    [items]=\"facetValues\"\r\n    [addTag]=\"false\"\r\n    [hideSelected]=\"true\"\r\n    bindValue=\"id\"\r\n    multiple=\"true\"\r\n    appendTo=\"body\"\r\n    bindLabel=\"name\"\r\n    [disabled]=\"disabled || readonly\"\r\n    [ngModel]=\"value\"\r\n    (change)=\"onChange($event)\"\r\n>\r\n    <ng-template ng-label-tmp let-item=\"item\" let-clear=\"clear\">\r\n        <vdr-facet-value-chip\r\n            *ngIf=\"item.value; else facetNotFound\"\r\n            [facetValue]=\"item.value\"\r\n            [removable]=\"!readonly\"\r\n            (remove)=\"clear(item)\"\r\n        ></vdr-facet-value-chip>\r\n        <ng-template #facetNotFound>\r\n            <vdr-chip colorType=\"error\" icon=\"times\" (iconClick)=\"clear(item)\">{{\r\n                'catalog.facet-value-not-available' | translate: { id: item.id }\r\n            }}</vdr-chip>\r\n        </ng-template>\r\n    </ng-template>\r\n    <ng-template ng-option-tmp let-item=\"item\">\r\n        <vdr-facet-value-chip [facetValue]=\"item.value\" [removable]=\"false\"></vdr-facet-value-chip>\r\n    </ng-template>\r\n</ng-select>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: FacetValueSelectorComponent,
+                        multi: true,
+                    },
+                ],
+                styles: [":host ::ng-deep .ng-select.ng-select-multiple .ng-select-container .ng-value-container .ng-value{background:none;margin:0}:host ::ng-deep .ng-dropdown-panel-items div.ng-option:last-child{display:none}:host ::ng-deep .ng-dropdown-panel .ng-dropdown-header{border:none;padding:0}:host ::ng-deep .ng-select.ng-select-multiple .ng-select-container .ng-value-container{padding:0}:host ::ng-deep .ng-select.ng-select-multiple .ng-select-container .ng-value-container .ng-placeholder{padding-left:8px}\n"]
+            },] }
+];
+FacetValueSelectorComponent.ctorParameters = () => [
+    { type: DataService }
+];
+FacetValueSelectorComponent.propDecorators = {
+    selectedValuesChange: [{ type: Output }],
+    facets: [{ type: Input }],
+    readonly: [{ type: Input }],
+    transformControlValueAccessorValue: [{ type: Input }],
+    ngSelect: [{ type: ViewChild, args: [NgSelectComponent,] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facet-value-selector.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/components/facet-value-selector/facet-value-selector.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    EventEmitter,\r\n    Input,\r\n    OnInit,\r\n    Output,\r\n    ViewChild,\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { NgSelectComponent } from '@ng-select/ng-select';\r\n\r\nimport { FacetValue, FacetWithValues } from '../../../common/generated-types';\r\nimport { flattenFacetValues } from '../../../common/utilities/flatten-facet-values';\r\nimport { DataService } from '../../../data/providers/data.service';\r\n\r\nexport type FacetValueSeletorItem = {\r\n    name: string;\r\n    facetName: string;\r\n    id: string;\r\n    value: FacetValue.Fragment;\r\n};\r\n\r\n/**\r\n * @description\r\n * A form control for selecting facet values.\r\n *\r\n * @example\r\n * ```HTML\r\n * <vdr-facet-value-selector\r\n *   [facets]=\"facets\"\r\n *   (selectedValuesChange)=\"selectedValues = $event\"\r\n * ></vdr-facet-value-selector>\r\n * ```\r\n * The `facets` input should be provided from the parent component\r\n * like this:\r\n *\r\n * @example\r\n * ```TypeScript\r\n * this.facets = this.dataService\r\n *   .facet.getAllFacets()\r\n *   .mapSingle(data => data.facets.items);\r\n * ```\r\n * @docsCategory components\r\n */\r\n@Component({\r\n    selector: 'vdr-facet-value-selector',\r\n    templateUrl: './facet-value-selector.component.html',\r\n    styleUrls: ['./facet-value-selector.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    providers: [\r\n        {\r\n            provide: NG_VALUE_ACCESSOR,\r\n            useExisting: FacetValueSelectorComponent,\r\n            multi: true,\r\n        },\r\n    ],\r\n})\r\nexport class FacetValueSelectorComponent implements OnInit, ControlValueAccessor {\r\n    @Output() selectedValuesChange = new EventEmitter<FacetValue.Fragment[]>();\r\n    @Input() facets: FacetWithValues.Fragment[];\r\n    @Input() readonly = false;\r\n    @Input() transformControlValueAccessorValue: (value: FacetValueSeletorItem[]) => any[] = value => value;\r\n\r\n    @ViewChild(NgSelectComponent) private ngSelect: NgSelectComponent;\r\n\r\n    facetValues: FacetValueSeletorItem[] = [];\r\n    onChangeFn: (val: any) => void;\r\n    onTouchFn: () => void;\r\n    disabled = false;\r\n    value: Array<string | FacetValue.Fragment>;\r\n    constructor(private dataService: DataService) {}\r\n\r\n    ngOnInit() {\r\n        this.facetValues = flattenFacetValues(this.facets).map(this.toSelectorItem);\r\n    }\r\n\r\n    onChange(selected: FacetValueSeletorItem[]) {\r\n        if (this.readonly) {\r\n            return;\r\n        }\r\n        this.selectedValuesChange.emit(selected.map(s => s.value));\r\n        if (this.onChangeFn) {\r\n            const transformedValue = this.transformControlValueAccessorValue(selected);\r\n            this.onChangeFn(transformedValue);\r\n        }\r\n    }\r\n\r\n    registerOnChange(fn: any) {\r\n        this.onChangeFn = fn;\r\n    }\r\n\r\n    registerOnTouched(fn: any) {\r\n        this.onTouchFn = fn;\r\n    }\r\n\r\n    setDisabledState(isDisabled: boolean): void {\r\n        this.disabled = isDisabled;\r\n    }\r\n\r\n    focus() {\r\n        this.ngSelect.focus();\r\n    }\r\n\r\n    writeValue(obj: string | FacetValue.Fragment[] | Array<string | number> | null): void {\r\n        if (typeof obj === 'string') {\r\n            try {\r\n                const facetIds = JSON.parse(obj) as string[];\r\n                this.value = facetIds;\r\n            } catch (err) {\r\n                // TODO: log error\r\n                throw err;\r\n            }\r\n        } else if (Array.isArray(obj)) {\r\n            const isIdArray = (input: unknown[]): input is Array<string | number> =>\r\n                input.every(i => typeof i === 'number' || typeof i === 'string');\r\n            if (isIdArray(obj)) {\r\n                this.value = obj.map(fv => fv.toString());\r\n            } else {\r\n                this.value = obj.map(fv => fv.id);\r\n            }\r\n        }\r\n    }\r\n\r\n    private toSelectorItem = (facetValue: FacetValue.Fragment): FacetValueSeletorItem => {\r\n        return {\r\n            name: facetValue.name,\r\n            facetName: facetValue.facet.name,\r\n            id: facetValue.id,\r\n            value: facetValue,\r\n        };\r\n    };\r\n}\r\n"]}

package/package/esm2015/core/shared/components/language-selector/language-selector.component.js

@@ -0,0 +1,21 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+export class LanguageSelectorComponent {
+    constructor() {
+        this.disabled = false;
+        this.languageCodeChange = new EventEmitter();
+    }
+}
+LanguageSelectorComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-language-selector',
+                template: "<ng-container *ngIf=\"1 < availableLanguageCodes?.length\">\r\n    <vdr-dropdown>\r\n        <button type=\"button\" class=\"btn btn-sm\" vdrDropdownTrigger [disabled]=\"disabled\">\r\n            <clr-icon shape=\"world\"></clr-icon>\r\n            {{ 'common.language' | translate }}: {{ currentLanguageCode | localeLanguageName | uppercase }}\r\n            <clr-icon shape=\"caret down\"></clr-icon>\r\n        </button>\r\n        <vdr-dropdown-menu vdrPosition=\"bottom-right\">\r\n            <button\r\n                type=\"button\"\r\n                *ngFor=\"let code of availableLanguageCodes\"\r\n                (click)=\"languageCodeChange.emit(code)\"\r\n                vdrDropdownItem\r\n            >\r\n                <span>{{ code | localeLanguageName }}</span> <span class=\"code ml2\">{{ code }}</span>\r\n            </button>\r\n        </vdr-dropdown-menu>\r\n    </vdr-dropdown>\r\n</ng-container>\r\n",
+                styles: [".code{color:var(--color-grey-400)}\n"]
+            },] }
+];
+LanguageSelectorComponent.propDecorators = {
+    currentLanguageCode: [{ type: Input }],
+    availableLanguageCodes: [{ type: Input }],
+    disabled: [{ type: Input }],
+    languageCodeChange: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2Utc2VsZWN0b3IuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb3JlL3NyYy9zaGFyZWQvY29tcG9uZW50cy9sYW5ndWFnZS1zZWxlY3Rvci9sYW5ndWFnZS1zZWxlY3Rvci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQVN2RSxNQUFNLE9BQU8seUJBQXlCO0lBTHRDO1FBUWEsYUFBUSxHQUFHLEtBQUssQ0FBQztRQUNoQix1QkFBa0IsR0FBRyxJQUFJLFlBQVksRUFBZ0IsQ0FBQztJQUNwRSxDQUFDOzs7WUFWQSxTQUFTLFNBQUM7Z0JBQ1AsUUFBUSxFQUFFLHVCQUF1QjtnQkFDakMsODZCQUFpRDs7YUFFcEQ7OztrQ0FFSSxLQUFLO3FDQUNMLEtBQUs7dUJBQ0wsS0FBSztpQ0FDTCxNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBFdmVudEVtaXR0ZXIsIElucHV0LCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IExhbmd1YWdlQ29kZSB9IGZyb20gJy4uLy4uLy4uL2NvbW1vbi9nZW5lcmF0ZWQtdHlwZXMnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgICBzZWxlY3RvcjogJ3Zkci1sYW5ndWFnZS1zZWxlY3RvcicsXHJcbiAgICB0ZW1wbGF0ZVVybDogJy4vbGFuZ3VhZ2Utc2VsZWN0b3IuY29tcG9uZW50Lmh0bWwnLFxyXG4gICAgc3R5bGVVcmxzOiBbJy4vbGFuZ3VhZ2Utc2VsZWN0b3IuY29tcG9uZW50LnNjc3MnXSxcclxufSlcclxuZXhwb3J0IGNsYXNzIExhbmd1YWdlU2VsZWN0b3JDb21wb25lbnQge1xyXG4gICAgQElucHV0KCkgY3VycmVudExhbmd1YWdlQ29kZTogTGFuZ3VhZ2VDb2RlO1xyXG4gICAgQElucHV0KCkgYXZhaWxhYmxlTGFuZ3VhZ2VDb2RlczogTGFuZ3VhZ2VDb2RlW107XHJcbiAgICBASW5wdXQoKSBkaXNhYmxlZCA9IGZhbHNlO1xyXG4gICAgQE91dHB1dCgpIGxhbmd1YWdlQ29kZUNoYW5nZSA9IG5ldyBFdmVudEVtaXR0ZXI8TGFuZ3VhZ2VDb2RlPigpO1xyXG59XHJcbiJdfQ==

package/package/esm2015/core/shared/components/order-state-label/order-state-label.component.js

@@ -0,0 +1,44 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+/**
+ * @description
+ * Displays the state of an order in a colored chip.
+ *
+ * @example
+ * ```HTML
+ * <vdr-order-state-label [state]="order.state"></vdr-order-state-label>
+ * ```
+ * @docsCategory components
+ */
+export class OrderStateLabelComponent {
+    get chipColorType() {
+        switch (this.state) {
+            case 'AddingItems':
+            case 'ArrangingPayment':
+                return '';
+            case 'Delivered':
+                return 'success';
+            case 'Cancelled':
+            case 'Draft':
+                return 'error';
+            case 'PaymentAuthorized':
+            case 'PaymentSettled':
+            case 'PartiallyDelivered':
+            case 'PartiallyShipped':
+            case 'Shipped':
+            default:
+                return 'warning';
+        }
+    }
+}
+OrderStateLabelComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-order-state-label',
+                template: "<vdr-chip [ngClass]=\"state\" [colorType]=\"chipColorType\">\r\n    <clr-icon shape=\"success-standard\" *ngIf=\"state === 'Delivered'\" size=\"12\"></clr-icon>\r\n    <clr-icon shape=\"success-standard\" *ngIf=\"state === 'PartiallyDelivered'\" size=\"12\"></clr-icon>\r\n    <clr-icon shape=\"ban\" *ngIf=\"state === 'Cancelled'\" size=\"12\"></clr-icon>\r\n    {{ state | stateI18nToken | translate }}\r\n    <ng-content></ng-content>\r\n</vdr-chip>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: ["clr-icon{margin-right:3px}\n"]
+            },] }
+];
+OrderStateLabelComponent.propDecorators = {
+    state: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package/esm2015/core/shared/components/product-search-input/product-search-input.component.js

@@ -0,0 +1,104 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { SELECTION_MODEL_FACTORY } from '@ng-select/ng-select';
+import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
+import { SingleSearchSelectionModelFactory } from '../../../common/single-search-selection-model';
+const ɵ0 = SingleSearchSelectionModelFactory;
+export class ProductSearchInputComponent {
+    constructor() {
+        this.searchTermChange = new EventEmitter();
+        this.facetValueChange = new EventEmitter();
+        this.lastTerm = '';
+        this.lastFacetValueIds = [];
+        this.filterFacetResults = (term, item) => {
+            if (!this.isFacetValueItem(item)) {
+                return false;
+            }
+            const cix = term.indexOf(':');
+            const facetName = cix > -1 ? term.toLowerCase().slice(0, cix) : null;
+            const facetVal = cix > -1 ? term.toLowerCase().slice(cix + 1) : term.toLowerCase();
+            if (facetName) {
+                return (item.facetValue.facet.name.toLowerCase().includes(facetName) &&
+                    item.facetValue.name.toLocaleLowerCase().includes(facetVal));
+            }
+            return (item.facetValue.name.toLowerCase().includes(term.toLowerCase()) ||
+                item.facetValue.facet.name.toLowerCase().includes(term.toLowerCase()));
+        };
+        this.isFacetValueItem = (input) => {
+            return typeof input === 'object' && !!input && input.hasOwnProperty('facetValue');
+        };
+    }
+    setSearchTerm(term) {
+        if (term) {
+            this.selectComponent.select({ label: term, value: { label: term } });
+        }
+        else {
+            const currentTerm = this.selectComponent.selectedItems.find(i => !this.isFacetValueItem(i.value));
+            if (currentTerm) {
+                this.selectComponent.unselect(currentTerm);
+            }
+        }
+    }
+    setFacetValues(ids) {
+        const items = this.selectComponent.items;
+        this.selectComponent.selectedItems.forEach(item => {
+            if (this.isFacetValueItem(item.value) && !ids.includes(item.value.facetValue.id)) {
+                this.selectComponent.unselect(item);
+            }
+        });
+        ids.map(id => {
+            return items === null || items === void 0 ? void 0 : items.find(item => this.isFacetValueItem(item) && item.facetValue.id === id);
+        })
+            .filter(notNullOrUndefined)
+            .forEach(item => {
+            const isSelected = this.selectComponent.selectedItems.find(i => {
+                const val = i.value;
+                if (this.isFacetValueItem(val)) {
+                    return val.facetValue.id === item.facetValue.id;
+                }
+                return false;
+            });
+            if (!isSelected) {
+                this.selectComponent.select({ label: '', value: item });
+            }
+        });
+    }
+    onSelectChange(selectedItems) {
+        if (!Array.isArray(selectedItems)) {
+            selectedItems = [selectedItems];
+        }
+        const searchTermItem = selectedItems.find(item => !this.isFacetValueItem(item));
+        const searchTerm = searchTermItem ? searchTermItem.label : '';
+        const facetValueIds = selectedItems.filter(this.isFacetValueItem).map(i => i.facetValue.id);
+        if (searchTerm !== this.lastTerm) {
+            this.searchTermChange.emit(searchTerm);
+            this.lastTerm = searchTerm;
+        }
+        if (this.lastFacetValueIds.join(',') !== facetValueIds.join(',')) {
+            this.facetValueChange.emit(facetValueIds);
+            this.lastFacetValueIds = facetValueIds;
+        }
+    }
+    addTagFn(item) {
+        return { label: item };
+    }
+    isSearchHeaderSelected() {
+        return this.selectComponent.itemsList.markedIndex === -1;
+    }
+}
+ProductSearchInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-product-search-input',
+                template: "<ng-select\r\n    [addTag]=\"addTagFn\"\r\n    [placeholder]=\"'catalog.search-product-name-or-code' | translate\"\r\n    [items]=\"facetValueResults\"\r\n    [searchFn]=\"filterFacetResults\"\r\n    [hideSelected]=\"true\"\r\n    [multiple]=\"true\"\r\n    [markFirst]=\"false\"\r\n    (change)=\"onSelectChange($event)\"\r\n    #selectComponent\r\n>\r\n    <ng-template ng-header-tmp>\r\n        <div\r\n            class=\"search-header\"\r\n            *ngIf=\"selectComponent.searchTerm\"\r\n            [class.selected]=\"isSearchHeaderSelected()\"\r\n            (click)=\"selectComponent.selectTag()\"\r\n        >\r\n            {{ 'catalog.search-for-term' | translate }}: {{ selectComponent.searchTerm }}\r\n        </div>\r\n    </ng-template>\r\n    <ng-template ng-label-tmp let-item=\"item\" let-clear=\"clear\">\r\n        <ng-container *ngIf=\"item.facetValue\">\r\n            <vdr-facet-value-chip\r\n                [facetValue]=\"item.facetValue\"\r\n                [removable]=\"true\"\r\n                (remove)=\"clear(item)\"\r\n            ></vdr-facet-value-chip>\r\n        </ng-container>\r\n        <ng-container *ngIf=\"!item.facetValue\">\r\n            <vdr-chip [icon]=\"'times'\" (iconClick)=\"clear(item)\">\"{{ item.label }}\"</vdr-chip>\r\n        </ng-container>\r\n    </ng-template>\r\n    <ng-template ng-option-tmp let-item=\"item\" let-index=\"index\" let-search=\"searchTerm\">\r\n        <ng-container *ngIf=\"item.facetValue\">\r\n            <vdr-facet-value-chip [facetValue]=\"item.facetValue\" [removable]=\"false\"></vdr-facet-value-chip>\r\n        </ng-container>\r\n    </ng-template>\r\n</ng-select>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [{ provide: SELECTION_MODEL_FACTORY, useValue: ɵ0 }],
+                styles: [":host{margin-top:6px;display:block;width:100%}:host ::ng-deep .ng-select.ng-select-multiple .ng-select-container .ng-value-container .ng-value{background:none;margin:0}:host ::ng-deep .ng-dropdown-panel-items div.ng-option:last-child{display:none}:host ::ng-deep .ng-dropdown-panel .ng-dropdown-header{border:none;padding:0}:host ::ng-deep .ng-select.ng-select-multiple .ng-select-container .ng-value-container{padding:0}:host ::ng-deep .ng-select.ng-select-multiple .ng-select-container .ng-value-container .ng-placeholder{padding-left:8px}ng-select{width:100%;margin-right:12px}.search-header{padding:8px 10px;border-bottom:1px solid var(--color-component-border-100);cursor:pointer}.search-header.selected,.search-header:hover{background-color:var(--color-component-bg-200)}\n"]
+            },] }
+];
+ProductSearchInputComponent.propDecorators = {
+    facetValueResults: [{ type: Input }],
+    searchTermChange: [{ type: Output }],
+    facetValueChange: [{ type: Output }],
+    selectComponent: [{ type: ViewChild, args: ['selectComponent', { static: true },] }]
+};
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-search-input.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/components/product-search-input/product-search-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';\r\nimport { NgSelectComponent, SELECTION_MODEL_FACTORY } from '@ng-select/ng-select';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\n\r\nimport { SearchProducts } from '../../../common/generated-types';\r\nimport { SingleSearchSelectionModelFactory } from '../../../common/single-search-selection-model';\r\n\r\n@Component({\r\n    selector: 'vdr-product-search-input',\r\n    templateUrl: './product-search-input.component.html',\r\n    styleUrls: ['./product-search-input.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    providers: [{ provide: SELECTION_MODEL_FACTORY, useValue: SingleSearchSelectionModelFactory }],\r\n})\r\nexport class ProductSearchInputComponent {\r\n    @Input() facetValueResults: SearchProducts.FacetValues[];\r\n    @Output() searchTermChange = new EventEmitter<string>();\r\n    @Output() facetValueChange = new EventEmitter<string[]>();\r\n    @ViewChild('selectComponent', { static: true }) private selectComponent: NgSelectComponent;\r\n    private lastTerm = '';\r\n    private lastFacetValueIds: string[] = [];\r\n\r\n    setSearchTerm(term: string | null) {\r\n        if (term) {\r\n            this.selectComponent.select({ label: term, value: { label: term } });\r\n        } else {\r\n            const currentTerm = this.selectComponent.selectedItems.find(i => !this.isFacetValueItem(i.value));\r\n            if (currentTerm) {\r\n                this.selectComponent.unselect(currentTerm);\r\n            }\r\n        }\r\n    }\r\n\r\n    setFacetValues(ids: string[]) {\r\n        const items = this.selectComponent.items;\r\n\r\n        this.selectComponent.selectedItems.forEach(item => {\r\n            if (this.isFacetValueItem(item.value) && !ids.includes(item.value.facetValue.id)) {\r\n                this.selectComponent.unselect(item);\r\n            }\r\n        });\r\n\r\n        ids.map(id => {\r\n            return items?.find(item => this.isFacetValueItem(item) && item.facetValue.id === id);\r\n        })\r\n            .filter(notNullOrUndefined)\r\n            .forEach(item => {\r\n                const isSelected = this.selectComponent.selectedItems.find(i => {\r\n                    const val = i.value;\r\n                    if (this.isFacetValueItem(val)) {\r\n                        return val.facetValue.id === item.facetValue.id;\r\n                    }\r\n                    return false;\r\n                });\r\n                if (!isSelected) {\r\n                    this.selectComponent.select({ label: '', value: item });\r\n                }\r\n            });\r\n    }\r\n\r\n    filterFacetResults = (term: string, item: SearchProducts.FacetValues | { label: string }) => {\r\n        if (!this.isFacetValueItem(item)) {\r\n            return false;\r\n        }\r\n\r\n        const cix = term.indexOf(':');\r\n        const facetName = cix > -1 ? term.toLowerCase().slice(0, cix) : null;\r\n        const facetVal = cix > -1 ? term.toLowerCase().slice(cix + 1) : term.toLowerCase();\r\n\r\n        if (facetName) {\r\n            return (\r\n                item.facetValue.facet.name.toLowerCase().includes(facetName) &&\r\n                item.facetValue.name.toLocaleLowerCase().includes(facetVal)\r\n            );\r\n        }\r\n\r\n        return (\r\n            item.facetValue.name.toLowerCase().includes(term.toLowerCase()) ||\r\n            item.facetValue.facet.name.toLowerCase().includes(term.toLowerCase())\r\n        );\r\n    };\r\n\r\n    onSelectChange(selectedItems: Array<SearchProducts.FacetValues | { label: string }>) {\r\n        if (!Array.isArray(selectedItems)) {\r\n            selectedItems = [selectedItems];\r\n        }\r\n        const searchTermItem = selectedItems.find(item => !this.isFacetValueItem(item)) as\r\n            | { label: string }\r\n            | undefined;\r\n        const searchTerm = searchTermItem ? searchTermItem.label : '';\r\n\r\n        const facetValueIds = selectedItems.filter(this.isFacetValueItem).map(i => i.facetValue.id);\r\n\r\n        if (searchTerm !== this.lastTerm) {\r\n            this.searchTermChange.emit(searchTerm);\r\n            this.lastTerm = searchTerm;\r\n        }\r\n        if (this.lastFacetValueIds.join(',') !== facetValueIds.join(',')) {\r\n            this.facetValueChange.emit(facetValueIds);\r\n            this.lastFacetValueIds = facetValueIds;\r\n        }\r\n    }\r\n\r\n    addTagFn(item: any) {\r\n        return { label: item };\r\n    }\r\n\r\n    isSearchHeaderSelected(): boolean {\r\n        return this.selectComponent.itemsList.markedIndex === -1;\r\n    }\r\n\r\n    private isFacetValueItem = (input: unknown): input is SearchProducts.FacetValues => {\r\n        return typeof input === 'object' && !!input && input.hasOwnProperty('facetValue');\r\n    };\r\n}\r\n"]}

package/package/esm2015/core/shared/components/product-selector/product-selector.component.js

@@ -0,0 +1,61 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Output, ViewChild } from '@angular/core';
+import { concat, merge, of, Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, mapTo, switchMap, tap } from 'rxjs/operators';
+import { DataService } from '../../../data/providers/data.service';
+/**
+ * @description
+ * A component for selecting product variants via an autocomplete-style select input.
+ *
+ * @example
+ * ```HTML
+ * <vdr-product-selector
+ *   (productSelected)="selectResult($event)"></vdr-product-selector>
+ * ```
+ *
+ * @docsCategory components
+ */
+export class ProductSelectorComponent {
+    constructor(dataService) {
+        this.dataService = dataService;
+        this.searchInput$ = new Subject();
+        this.searchLoading = false;
+        this.productSelected = new EventEmitter();
+    }
+    ngOnInit() {
+        this.initSearchResults();
+    }
+    initSearchResults() {
+        const searchItems$ = this.searchInput$.pipe(debounceTime(200), distinctUntilChanged(), tap(() => (this.searchLoading = true)), switchMap(term => {
+            if (!term) {
+                return of([]);
+            }
+            return this.dataService.product
+                .productSelectorSearch(term, 10)
+                .mapSingle(result => result.search.items);
+        }), tap(() => (this.searchLoading = false)));
+        const clear$ = this.productSelected.pipe(mapTo([]));
+        this.searchResults$ = concat(of([]), merge(searchItems$, clear$));
+    }
+    selectResult(product) {
+        if (product) {
+            this.productSelected.emit(product);
+            this.ngSelect.clearModel();
+        }
+    }
+}
+ProductSelectorComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-product-selector',
+                template: "<ng-select\r\n    #autoComplete\r\n    [items]=\"searchResults$ | async\"\r\n    [addTag]=\"false\"\r\n    [multiple]=\"false\"\r\n    [hideSelected]=\"true\"\r\n    [loading]=\"searchLoading\"\r\n    [typeahead]=\"searchInput$\"\r\n    [appendTo]=\"'body'\"\r\n    [placeholder]=\"'settings.search-by-product-name-or-sku' | translate\"\r\n    (change)=\"selectResult($event)\"\r\n>\r\n    <ng-template ng-option-tmp let-item=\"item\">\r\n        <img [src]=\"item.productAsset | assetPreview: 32\">\r\n        {{ item.productVariantName }}\r\n        <small class=\"sku\">{{ item.sku }}</small>\r\n    </ng-template>\r\n</ng-select>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{display:block}.sku{margin-left:12px;color:var(--color-grey-500)}img{border-radius:var(--border-radius-img)}\n"]
+            },] }
+];
+ProductSelectorComponent.ctorParameters = () => [
+    { type: DataService }
+];
+ProductSelectorComponent.propDecorators = {
+    productSelected: [{ type: Output }],
+    ngSelect: [{ type: ViewChild, args: ['autoComplete', { static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdC1zZWxlY3Rvci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3Byb2R1Y3Qtc2VsZWN0b3IvcHJvZHVjdC1zZWxlY3Rvci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQVUsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU1RyxPQUFPLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBYyxFQUFFLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsb0JBQW9CLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxHQUFHLEVBQWdCLE1BQU0sZ0JBQWdCLENBQUM7QUFHekcsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRW5FOzs7Ozs7Ozs7OztHQVdHO0FBT0gsTUFBTSxPQUFPLHdCQUF3QjtJQVFqQyxZQUFvQixXQUF3QjtRQUF4QixnQkFBVyxHQUFYLFdBQVcsQ0FBYTtRQVA1QyxpQkFBWSxHQUFHLElBQUksT0FBTyxFQUFVLENBQUM7UUFDckMsa0JBQWEsR0FBRyxLQUFLLENBQUM7UUFFWixvQkFBZSxHQUFHLElBQUksWUFBWSxFQUErQixDQUFDO0lBSTdCLENBQUM7SUFFaEQsUUFBUTtRQUNKLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFFTyxpQkFBaUI7UUFDckIsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQ3ZDLFlBQVksQ0FBQyxHQUFHLENBQUMsRUFDakIsb0JBQW9CLEVBQUUsRUFDdEIsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUMsQ0FBQyxFQUN0QyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDYixJQUFJLENBQUMsSUFBSSxFQUFFO2dCQUNQLE9BQU8sRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO2FBQ2pCO1lBQ0QsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU87aUJBQzFCLHFCQUFxQixDQUFDLElBQUksRUFBRSxFQUFFLENBQUM7aUJBQy9CLFNBQVMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDbEQsQ0FBQyxDQUFDLEVBQ0YsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUMxQyxDQUFDO1FBRUYsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLGNBQWMsR0FBRyxNQUFNLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLEtBQUssQ0FBQyxZQUFZLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRUQsWUFBWSxDQUFDLE9BQXFDO1FBQzlDLElBQUksT0FBTyxFQUFFO1lBQ1QsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDbkMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQztTQUM5QjtJQUNMLENBQUM7OztZQTdDSixTQUFTLFNBQUM7Z0JBQ1AsUUFBUSxFQUFFLHNCQUFzQjtnQkFDaEMseW9CQUFnRDtnQkFFaEQsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07O2FBQ2xEOzs7WUFuQlEsV0FBVzs7OzhCQXdCZixNQUFNO3VCQUVOLFNBQVMsU0FBQyxjQUFjLEVBQUUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgRXZlbnRFbWl0dGVyLCBPbkluaXQsIE91dHB1dCwgVmlld0NoaWxkIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE5nU2VsZWN0Q29tcG9uZW50IH0gZnJvbSAnQG5nLXNlbGVjdC9uZy1zZWxlY3QnO1xyXG5pbXBvcnQgeyBjb25jYXQsIG1lcmdlLCBPYnNlcnZhYmxlLCBvZiwgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQgeyBkZWJvdW5jZVRpbWUsIGRpc3RpbmN0VW50aWxDaGFuZ2VkLCBtYXBUbywgc3dpdGNoTWFwLCB0YXAsIHRocm90dGxlVGltZSB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuXHJcbmltcG9ydCB7IFByb2R1Y3RTZWxlY3RvclNlYXJjaCB9IGZyb20gJy4uLy4uLy4uL2NvbW1vbi9nZW5lcmF0ZWQtdHlwZXMnO1xyXG5pbXBvcnQgeyBEYXRhU2VydmljZSB9IGZyb20gJy4uLy4uLy4uL2RhdGEvcHJvdmlkZXJzL2RhdGEuc2VydmljZSc7XHJcblxyXG4vKipcclxuICogQGRlc2NyaXB0aW9uXHJcbiAqIEEgY29tcG9uZW50IGZvciBzZWxlY3RpbmcgcHJvZHVjdCB2YXJpYW50cyB2aWEgYW4gYXV0b2NvbXBsZXRlLXN0eWxlIHNlbGVjdCBpbnB1dC5cclxuICpcclxuICogQGV4YW1wbGVcclxuICogYGBgSFRNTFxyXG4gKiA8dmRyLXByb2R1Y3Qtc2VsZWN0b3JcclxuICogICAocHJvZHVjdFNlbGVjdGVkKT1cInNlbGVjdFJlc3VsdCgkZXZlbnQpXCI+PC92ZHItcHJvZHVjdC1zZWxlY3Rvcj5cclxuICogYGBgXHJcbiAqXHJcbiAqIEBkb2NzQ2F0ZWdvcnkgY29tcG9uZW50c1xyXG4gKi9cclxuQENvbXBvbmVudCh7XHJcbiAgICBzZWxlY3RvcjogJ3Zkci1wcm9kdWN0LXNlbGVjdG9yJyxcclxuICAgIHRlbXBsYXRlVXJsOiAnLi9wcm9kdWN0LXNlbGVjdG9yLmNvbXBvbmVudC5odG1sJyxcclxuICAgIHN0eWxlVXJsczogWycuL3Byb2R1Y3Qtc2VsZWN0b3IuY29tcG9uZW50LnNjc3MnXSxcclxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgUHJvZHVjdFNlbGVjdG9yQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcclxuICAgIHNlYXJjaElucHV0JCA9IG5ldyBTdWJqZWN0PHN0cmluZz4oKTtcclxuICAgIHNlYXJjaExvYWRpbmcgPSBmYWxzZTtcclxuICAgIHNlYXJjaFJlc3VsdHMkOiBPYnNlcnZhYmxlPFByb2R1Y3RTZWxlY3RvclNlYXJjaC5JdGVtc1tdPjtcclxuICAgIEBPdXRwdXQoKSBwcm9kdWN0U2VsZWN0ZWQgPSBuZXcgRXZlbnRFbWl0dGVyPFByb2R1Y3RTZWxlY3RvclNlYXJjaC5JdGVtcz4oKTtcclxuXHJcbiAgICBAVmlld0NoaWxkKCdhdXRvQ29tcGxldGUnLCB7IHN0YXRpYzogdHJ1ZSB9KVxyXG4gICAgcHJpdmF0ZSBuZ1NlbGVjdDogTmdTZWxlY3RDb21wb25lbnQ7XHJcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIGRhdGFTZXJ2aWNlOiBEYXRhU2VydmljZSkge31cclxuXHJcbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLmluaXRTZWFyY2hSZXN1bHRzKCk7XHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSBpbml0U2VhcmNoUmVzdWx0cygpIHtcclxuICAgICAgICBjb25zdCBzZWFyY2hJdGVtcyQgPSB0aGlzLnNlYXJjaElucHV0JC5waXBlKFxyXG4gICAgICAgICAgICBkZWJvdW5jZVRpbWUoMjAwKSxcclxuICAgICAgICAgICAgZGlzdGluY3RVbnRpbENoYW5nZWQoKSxcclxuICAgICAgICAgICAgdGFwKCgpID0+ICh0aGlzLnNlYXJjaExvYWRpbmcgPSB0cnVlKSksXHJcbiAgICAgICAgICAgIHN3aXRjaE1hcCh0ZXJtID0+IHtcclxuICAgICAgICAgICAgICAgIGlmICghdGVybSkge1xyXG4gICAgICAgICAgICAgICAgICAgIHJldHVybiBvZihbXSk7XHJcbiAgICAgICAgICAgICAgICB9XHJcbiAgICAgICAgICAgICAgICByZXR1cm4gdGhpcy5kYXRhU2VydmljZS5wcm9kdWN0XHJcbiAgICAgICAgICAgICAgICAgICAgLnByb2R1Y3RTZWxlY3RvclNlYXJjaCh0ZXJtLCAxMClcclxuICAgICAgICAgICAgICAgICAgICAubWFwU2luZ2xlKHJlc3VsdCA9PiByZXN1bHQuc2VhcmNoLml0ZW1zKTtcclxuICAgICAgICAgICAgfSksXHJcbiAgICAgICAgICAgIHRhcCgoKSA9PiAodGhpcy5zZWFyY2hMb2FkaW5nID0gZmFsc2UpKSxcclxuICAgICAgICApO1xyXG5cclxuICAgICAgICBjb25zdCBjbGVhciQgPSB0aGlzLnByb2R1Y3RTZWxlY3RlZC5waXBlKG1hcFRvKFtdKSk7XHJcbiAgICAgICAgdGhpcy5zZWFyY2hSZXN1bHRzJCA9IGNvbmNhdChvZihbXSksIG1lcmdlKHNlYXJjaEl0ZW1zJCwgY2xlYXIkKSk7XHJcbiAgICB9XHJcblxyXG4gICAgc2VsZWN0UmVzdWx0KHByb2R1Y3Q/OiBQcm9kdWN0U2VsZWN0b3JTZWFyY2guSXRlbXMpIHtcclxuICAgICAgICBpZiAocHJvZHVjdCkge1xyXG4gICAgICAgICAgICB0aGlzLnByb2R1Y3RTZWxlY3RlZC5lbWl0KHByb2R1Y3QpO1xyXG4gICAgICAgICAgICB0aGlzLm5nU2VsZWN0LmNsZWFyTW9kZWwoKTtcclxuICAgICAgICB9XHJcbiAgICB9XHJcbn1cclxuIl19