@festo-ui/angular 3.1.0 → 3.2.0

package/esm2020/lib/components/popovers/popover.service.mjs

@@ -0,0 +1,123 @@
+import { Injectable, Injector } from '@angular/core';
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { PopoverRef } from './popover-ref';
+import { PopoverComponent } from './popover/popover.component';
+import { defaultPositions, defaultClasses } from './popover.defaults';
+import { PopoverTypes, PopoverPosition } from './popover.models';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class PopoverService {
+    constructor(overlay, injector) {
+        this.overlay = overlay;
+        this.injector = injector;
+        this.options = {
+            type: PopoverTypes.Tooltip,
+            width: null,
+            height: null,
+            maxWidth: null,
+            maxHeight: null,
+            minWidth: null,
+            minHeight: null,
+            hasBackdrop: false,
+            backdropClass: 'fng-popover-backdrop',
+            positions: null
+        };
+    }
+    get defaultOptions() {
+        return this.options;
+    }
+    open({ origin, content, data, options }) {
+        if (null == options) {
+            options = this.defaultOptions;
+        }
+        const overlayConfig = this.getOverlayConfig({ origin, options });
+        const overlayRef = this.overlay.create(overlayConfig);
+        const popoverRef = new PopoverRef(overlayRef, content, data);
+        const injector = this.createInjector(popoverRef, this.injector);
+        overlayRef.attach(new ComponentPortal(PopoverComponent, null, injector));
+        return popoverRef;
+    }
+    getOverlayConfig({ origin, options }) {
+        const type = null != options.type ? options.type : this.defaultOptions.type;
+        const positions = null != options.positions ? options.positions : this.defaultOptions.positions;
+        return new OverlayConfig({
+            width: null != options.width ? options.width : this.defaultOptions.width,
+            height: null != options.height ? options.height : this.defaultOptions.height,
+            maxWidth: null != options.maxWidth ? options.maxWidth : this.defaultOptions.maxWidth,
+            maxHeight: null != options.maxHeight ? options.maxHeight : this.defaultOptions.maxHeight,
+            minWidth: null != options.minWidth ? options.minWidth : this.defaultOptions.minWidth,
+            minHeight: null != options.minHeight ? options.minHeight : this.defaultOptions.minHeight,
+            positionStrategy: this.getOverlayPosition(origin, type, positions),
+            scrollStrategy: null != this.overlay && null != this.overlay.scrollStrategies ? this.overlay.scrollStrategies.block() : {},
+            hasBackdrop: null != options.hasBackdrop ? options.hasBackdrop : this.defaultOptions.hasBackdrop,
+            backdropClass: null != options.backdropClass ? options.backdropClass : this.defaultOptions.backdropClass
+        });
+    }
+    getOverlayPosition(origin, type, positions) {
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(origin)
+            .withPositions(null != positions ? this.getPositions(type, positions) : this.getDefaultPositions(type))
+            .withFlexibleDimensions(false)
+            .withViewportMargin(16)
+            .withPush(false);
+        return positionStrategy;
+    }
+    createInjector(popoverRef, injector) {
+        return Injector.create({
+            parent: injector,
+            providers: [{ provide: PopoverRef, useValue: popoverRef }]
+        });
+    }
+    getDefaultPositions(type) {
+        const pairs = [];
+        let positions = [];
+        const fn = (t, p) => p.map(position => {
+            pairs.push({
+                ...defaultPositions[position],
+                panelClass: [defaultClasses[t], defaultClasses[position]]
+            });
+        });
+        switch (type) {
+            case PopoverTypes.Tooltip:
+                positions = [PopoverPosition.Bottom, PopoverPosition.Top];
+                fn(PopoverTypes.Tooltip, positions);
+                break;
+            case PopoverTypes.Menu:
+                positions = [PopoverPosition.Right, PopoverPosition.Left];
+                fn(PopoverTypes.Menu, positions);
+                break;
+            case PopoverTypes.Legend:
+                positions = [PopoverPosition.Bottom];
+                fn(PopoverTypes.Legend, positions);
+                break;
+            case PopoverTypes.Content:
+                positions = [PopoverPosition.Bottom];
+                fn(PopoverTypes.Content, positions);
+                break;
+            default:
+                break;
+        }
+        return pairs;
+    }
+    getPositions(type, positions) {
+        const pairs = [];
+        positions.map(position => {
+            pairs.push({
+                ...defaultPositions[position],
+                panelClass: [defaultClasses[type], defaultClasses[position]]
+            });
+        });
+        return pairs;
+    }
+}
+PopoverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PopoverService, deps: [{ token: i1.Overlay }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+PopoverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PopoverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PopoverService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.service.js","sourceRoot":"","sources":["../../../../../../../libs/angular/src/lib/components/popovers/popover.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\nimport {\n  Overlay,\n  ConnectionPositionPair,\n  OverlayConfig,\n  FlexibleConnectedPositionStrategy,\n  NoopScrollStrategy\n} from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\n\nimport { PopoverRef } from './popover-ref';\nimport { PopoverComponent } from './popover/popover.component';\nimport { defaultPositions, defaultClasses } from './popover.defaults';\nimport { PopoverParams, PopoverOptions, PopoverTypes, PopoverPosition } from './popover.models';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PopoverService {\n  readonly options: PopoverOptions = {\n    type: PopoverTypes.Tooltip,\n    width: null,\n    height: null,\n    maxWidth: null,\n    maxHeight: null,\n    minWidth: null,\n    minHeight: null,\n    hasBackdrop: false,\n    backdropClass: 'fng-popover-backdrop',\n    positions: null\n  };\n\n  get defaultOptions() {\n    return this.options;\n  }\n\n  constructor(private overlay: Overlay, private injector: Injector) {}\n\n  open<T>({ origin, content, data, options }: PopoverParams<T>): PopoverRef<T> {\n    if (null == options) {\n      options = this.defaultOptions;\n    }\n    const overlayConfig = this.getOverlayConfig({ origin, options });\n    const overlayRef = this.overlay.create(overlayConfig);\n    const popoverRef = new PopoverRef<T>(overlayRef, content, data);\n    const injector = this.createInjector(popoverRef, this.injector);\n\n    overlayRef.attach(new ComponentPortal(PopoverComponent, null, injector));\n\n    return popoverRef;\n  }\n\n  private getOverlayConfig({ origin, options }: { origin: HTMLElement; options: PopoverOptions }): OverlayConfig {\n    const type = null != options.type ? options.type : this.defaultOptions.type;\n    const positions = null != options.positions ? options.positions : this.defaultOptions.positions;\n    return new OverlayConfig({\n      width: null != options.width ? options.width : this.defaultOptions.width,\n      height: null != options.height ? options.height : this.defaultOptions.height,\n      maxWidth: null != options.maxWidth ? options.maxWidth : this.defaultOptions.maxWidth,\n      maxHeight: null != options.maxHeight ? options.maxHeight : this.defaultOptions.maxHeight,\n      minWidth: null != options.minWidth ? options.minWidth : this.defaultOptions.minWidth,\n      minHeight: null != options.minHeight ? options.minHeight : this.defaultOptions.minHeight,\n      positionStrategy: this.getOverlayPosition(origin, type, positions),\n      scrollStrategy:\n        null != this.overlay && null != this.overlay.scrollStrategies ? this.overlay.scrollStrategies.block() : ({} as NoopScrollStrategy),\n      hasBackdrop: null != options.hasBackdrop ? options.hasBackdrop : this.defaultOptions.hasBackdrop,\n      backdropClass: null != options.backdropClass ? options.backdropClass : this.defaultOptions.backdropClass\n    });\n  }\n\n  private getOverlayPosition(origin: HTMLElement, type: PopoverTypes, positions: PopoverPosition[]): FlexibleConnectedPositionStrategy {\n    const positionStrategy = this.overlay\n      .position()\n      .flexibleConnectedTo(origin)\n      .withPositions(null != positions ? this.getPositions(type, positions) : this.getDefaultPositions(type))\n      .withFlexibleDimensions(false)\n      .withViewportMargin(16)\n      .withPush(false);\n\n    return positionStrategy;\n  }\n\n  private createInjector(popoverRef: PopoverRef, injector: Injector) {\n    return Injector.create({\n      parent: injector,\n      providers: [{ provide: PopoverRef, useValue: popoverRef }]\n    });\n  }\n\n  private getDefaultPositions(type: PopoverTypes): ConnectionPositionPair[] {\n    const pairs: ConnectionPositionPair[] = [];\n    let positions = [];\n    const fn = (t: PopoverTypes, p: PopoverPosition[]) =>\n      p.map(position => {\n        pairs.push({\n          ...defaultPositions[position as string],\n          panelClass: [defaultClasses[t], defaultClasses[position]]\n        });\n      });\n    switch (type) {\n      case PopoverTypes.Tooltip:\n        positions = [PopoverPosition.Bottom, PopoverPosition.Top];\n        fn(PopoverTypes.Tooltip, positions);\n        break;\n      case PopoverTypes.Menu:\n        positions = [PopoverPosition.Right, PopoverPosition.Left];\n        fn(PopoverTypes.Menu, positions);\n        break;\n      case PopoverTypes.Legend:\n        positions = [PopoverPosition.Bottom];\n        fn(PopoverTypes.Legend, positions);\n        break;\n      case PopoverTypes.Content:\n        positions = [PopoverPosition.Bottom];\n        fn(PopoverTypes.Content, positions);\n        break;\n      default:\n        break;\n    }\n    return pairs;\n  }\n\n  private getPositions(type: PopoverTypes, positions: PopoverPosition[]): ConnectionPositionPair[] {\n    const pairs: ConnectionPositionPair[] = [];\n    positions.map(position => {\n      pairs.push({\n        ...defaultPositions[position as string],\n        panelClass: [defaultClasses[type], defaultClasses[position]]\n      });\n    });\n\n    return pairs;\n  }\n}\n"]}

package/esm2020/lib/components/popovers/tooltip/tooltip.directive.mjs

@@ -0,0 +1,100 @@
+import { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import { PopoverPosition } from './../popover.models';
+import { PopoverTypes } from '../popover.models';
+import { PopoverService } from '../popover.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../popover.service";
+export class TooltipDirective {
+    constructor(elmenetRef, popoverService) {
+        this.elmenetRef = elmenetRef;
+        this.popoverService = popoverService;
+        this.text = '';
+        this.isVisible = false;
+        this.positions = [];
+        this.options = {
+            maxWidth: 400,
+            delay: 0
+        };
+        this.innerIsVisible = false;
+        this.timeoutHandle = null;
+    }
+    ngOnChanges(changes) {
+        this.origin = this.elmenetRef.nativeElement;
+        if (changes?.isVisible?.currentValue === true) {
+            if (this.innerIsVisible === false) {
+                this.open();
+            }
+        }
+        if (changes?.isVisible?.currentValue === false) {
+            if (this.innerIsVisible === true) {
+                this.close();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.hide();
+    }
+    show() {
+        if (this.options?.delay > 0) {
+            this.timeoutHandle = setTimeout(() => {
+                this.open();
+            }, +this.options?.delay);
+        }
+        else {
+            this.open();
+        }
+    }
+    hide() {
+        if (this.timeoutHandle != null) {
+            clearTimeout(this.timeoutHandle);
+        }
+        this.close();
+    }
+    open() {
+        if (this.innerIsVisible === false) {
+            this.popoverRef = this.popoverService.open({
+                content: this.text,
+                origin: this.origin,
+                options: {
+                    type: PopoverTypes.Tooltip,
+                    maxWidth: this.options.maxWidth,
+                    // using a set here removes duplicate positions and ensures that at least the bottom position will be used
+                    positions: [...new Set([...this.positions, PopoverPosition.Bottom])]
+                }
+            });
+            this.innerIsVisible = true;
+        }
+    }
+    close() {
+        if (this.popoverRef != null) {
+            this.popoverRef.close();
+        }
+        this.innerIsVisible = false;
+    }
+}
+TooltipDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: TooltipDirective, deps: [{ token: i0.ElementRef }, { token: i1.PopoverService }], target: i0.ɵɵFactoryTarget.Directive });
+TooltipDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: TooltipDirective, selector: "[fngTooltip]", inputs: { text: ["fngTooltip", "text"], isVisible: ["fngTooltipVisible", "isVisible"], positions: ["fngTooltipPositions", "positions"], options: "options" }, host: { listeners: { "mouseenter": "show()", "mouseleave": "hide()" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fngTooltip]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.PopoverService }]; }, propDecorators: { text: [{
+                type: Input,
+                args: ['fngTooltip']
+            }], isVisible: [{
+                type: Input,
+                args: ['fngTooltipVisible']
+            }], positions: [{
+                type: Input,
+                args: ['fngTooltipPositions']
+            }], options: [{
+                type: Input
+            }], show: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], hide: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/progress/progress.component.mjs

@@ -0,0 +1,20 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProgressComponent {
+    constructor() {
+        this.background = 'white';
+    }
+}
+ProgressComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ProgressComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ProgressComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: ProgressComponent, selector: "fng-progress", inputs: { progress: "progress", error: "error", background: "background" }, ngImport: i0, template: "<div class=\"fwe-progress\">\n  <div\n    class=\"fwe-progress-bar\"\n    role=\"progressbar\"\n    [style.width.%]=\"progress\"\n    [class.fwe-bg-red]=\"error\"\n    [class.fwe-progress-bar-black]=\"background === 'black'\"\n    [class.fwe-progress-bar-background]=\"background === 'background'\"\n    [attr.aria-valuenow]=\"progress\"\n    aria-valuemin=\"0\"\n    aria-valuemax=\"100\"\n  ></div>\n</div>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ProgressComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fng-progress', template: "<div class=\"fwe-progress\">\n  <div\n    class=\"fwe-progress-bar\"\n    role=\"progressbar\"\n    [style.width.%]=\"progress\"\n    [class.fwe-bg-red]=\"error\"\n    [class.fwe-progress-bar-black]=\"background === 'black'\"\n    [class.fwe-progress-bar-background]=\"background === 'background'\"\n    [attr.aria-valuenow]=\"progress\"\n    aria-valuemin=\"0\"\n    aria-valuemax=\"100\"\n  ></div>\n</div>\n" }]
+        }], propDecorators: { progress: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], background: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3MuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50cy9wcm9ncmVzcy9wcm9ncmVzcy5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL3Byb2dyZXNzL3Byb2dyZXNzLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU1qRCxNQUFNLE9BQU8saUJBQWlCO0lBSjlCO1FBT1csZUFBVSxHQUFxQyxPQUFPLENBQUM7S0FDakU7OzhHQUpZLGlCQUFpQjtrR0FBakIsaUJBQWlCLGdJQ045Qiw0WkFhQTsyRkRQYSxpQkFBaUI7a0JBSjdCLFNBQVM7K0JBQ0UsY0FBYzs4QkFJZixRQUFRO3NCQUFoQixLQUFLO2dCQUNHLEtBQUs7c0JBQWIsS0FBSztnQkFDRyxVQUFVO3NCQUFsQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdmbmctcHJvZ3Jlc3MnLFxuICB0ZW1wbGF0ZVVybDogJy4vcHJvZ3Jlc3MuY29tcG9uZW50Lmh0bWwnXG59KVxuZXhwb3J0IGNsYXNzIFByb2dyZXNzQ29tcG9uZW50IHtcbiAgQElucHV0KCkgcHJvZ3Jlc3M6IG51bWJlcjtcbiAgQElucHV0KCkgZXJyb3I6IGJvb2xlYW47XG4gIEBJbnB1dCgpIGJhY2tncm91bmQ6ICd3aGl0ZScgfCAnYmFja2dyb3VuZCcgfCAnYmxhY2snID0gJ3doaXRlJztcbn1cbiIsIjxkaXYgY2xhc3M9XCJmd2UtcHJvZ3Jlc3NcIj5cbiAgPGRpdlxuICAgIGNsYXNzPVwiZndlLXByb2dyZXNzLWJhclwiXG4gICAgcm9sZT1cInByb2dyZXNzYmFyXCJcbiAgICBbc3R5bGUud2lkdGguJV09XCJwcm9ncmVzc1wiXG4gICAgW2NsYXNzLmZ3ZS1iZy1yZWRdPVwiZXJyb3JcIlxuICAgIFtjbGFzcy5md2UtcHJvZ3Jlc3MtYmFyLWJsYWNrXT1cImJhY2tncm91bmQgPT09ICdibGFjaydcIlxuICAgIFtjbGFzcy5md2UtcHJvZ3Jlc3MtYmFyLWJhY2tncm91bmRdPVwiYmFja2dyb3VuZCA9PT0gJ2JhY2tncm91bmQnXCJcbiAgICBbYXR0ci5hcmlhLXZhbHVlbm93XT1cInByb2dyZXNzXCJcbiAgICBhcmlhLXZhbHVlbWluPVwiMFwiXG4gICAgYXJpYS12YWx1ZW1heD1cIjEwMFwiXG4gID48L2Rpdj5cbjwvZGl2PlxuIl19

package/esm2020/lib/components/scroll/index.mjs

@@ -0,0 +1,2 @@
+export * from './scrollable.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL3Njcm9sbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zY3JvbGxhYmxlLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2020/lib/components/scroll/scrollable.directive.mjs

@@ -0,0 +1,72 @@
+import { Directive, ElementRef, Input, NgZone, Renderer2 } from '@angular/core';
+import SimpleBar from 'simplebar';
+import * as i0 from "@angular/core";
+export class ScrollableDirective {
+    constructor(el, ngZone, renderer) {
+        this.el = el;
+        this.ngZone = ngZone;
+        this.renderer = renderer;
+        this.scrollbarMinSize = 25;
+        this.isScrolling = false;
+    }
+    ngOnChanges(changes) {
+        if (changes?.viewReady.currentValue === true) {
+            this.initScrollbar();
+            this.initResizeObserver();
+        }
+    }
+    ngOnDestroy() {
+        this.resizeObserver?.disconnect();
+    }
+    initScrollbar() {
+        const el = this.el.nativeElement;
+        // yes, we explict want to run outside angular to avoid unnecessary change detection cycles
+        this.ngZone.runOutsideAngular(() => {
+            this.sb = new SimpleBar(el, { scrollbarMinSize: this.scrollbarMinSize });
+            this.sb.getScrollElement().addEventListener('scroll', this.delay(() => {
+                // triggered on scroll stop
+                this.isScrolling = false;
+            }), false);
+        });
+        this.updateMaxWidth();
+    }
+    initResizeObserver() {
+        const el = this.el.nativeElement;
+        this.resizeObserver = new ResizeObserver(() => {
+            this.updateMaxWidth();
+        });
+        this.resizeObserver.observe(el);
+    }
+    updateMaxWidth() {
+        const el = this.el.nativeElement;
+        const wrapper = el.querySelector('.simplebar-content-wrapper');
+        const width = el.getBoundingClientRect().width;
+        this.renderer.setStyle(wrapper, 'max-width', width + 'px');
+    }
+    delay(callback) {
+        let timer;
+        return () => {
+            if (!this.isScrolling) {
+                // triggered on scroll start
+                this.isScrolling = true;
+            }
+            window.clearTimeout(timer);
+            timer = window.setTimeout(callback, 50);
+        };
+    }
+}
+ScrollableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ScrollableDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+ScrollableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: ScrollableDirective, selector: "[fngScrollable]", inputs: { scrollbarMinSize: ["fngScrollableScrollbarMinSize", "scrollbarMinSize"], viewReady: ["fngScrollableViewReady", "viewReady"] }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ScrollableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fngScrollable]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }]; }, propDecorators: { scrollbarMinSize: [{
+                type: Input,
+                args: ['fngScrollableScrollbarMinSize']
+            }], viewReady: [{
+                type: Input,
+                args: ['fngScrollableViewReady']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/search-input/safe-html.pipe.mjs

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class SafeHtmlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value) {
+        return this.sanitizer.bypassSecurityTrustHtml(value);
+    }
+}
+SafeHtmlPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+SafeHtmlPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SafeHtmlPipe, name: "safeHtml" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safeHtml'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZS1odG1sLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL3NlYXJjaC1pbnB1dC9zYWZlLWh0bWwucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFZLE1BQU0sMkJBQTJCLENBQUM7OztBQUtuRSxNQUFNLE9BQU8sWUFBWTtJQUN2QixZQUFzQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUcsQ0FBQztJQUUxQyxTQUFTLENBQUMsS0FBVTtRQUN6QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsdUJBQXVCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDdkQsQ0FBQzs7eUdBTFUsWUFBWTt1R0FBWixZQUFZOzJGQUFaLFlBQVk7a0JBSHhCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLFVBQVU7aUJBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlSHRtbCB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuXG5AUGlwZSh7XG4gIG5hbWU6ICdzYWZlSHRtbCdcbn0pXG5leHBvcnQgY2xhc3MgU2FmZUh0bWxQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBzYW5pdGl6ZXI6IERvbVNhbml0aXplcikge31cblxuICBwdWJsaWMgdHJhbnNmb3JtKHZhbHVlOiBhbnkpOiBTYWZlSHRtbCB7XG4gICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RIdG1sKHZhbHVlKTtcbiAgfVxufVxuIl19

package/esm2020/lib/components/search-input/search-input.component.mjs

@@ -0,0 +1,172 @@
+import { Component, Input, ViewChild, ElementRef, ViewEncapsulation, Output, EventEmitter, HostListener } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "../click-outside.directive";
+import * as i2 from "@angular/common";
+import * as i3 from "./safe-html.pipe";
+export class SearchSuggestion {
+    /**
+     * Creates a basic Suggestion from a string. The first query match is highlighted by bold tags.
+     * @param suggestionString The suggested string (should contain the whole query)
+     * @param query The current query. This string will be highlighted.
+     * @returns a html-string.
+     */
+    static basicSuggestion(suggestionString, query) {
+        const i = suggestionString.toLocaleLowerCase().indexOf(query.toLocaleLowerCase());
+        let template = suggestionString;
+        if (i != -1) {
+            const boldStart = i;
+            const boldEnd = i + query.length;
+            const part1 = suggestionString.substring(0, boldStart);
+            const part2 = suggestionString.substring(boldStart, boldEnd);
+            const part3 = suggestionString.substring(boldEnd, suggestionString.length);
+            template = part1 + '<b>' + part2 + '</b>' + part3;
+        }
+        return { value: suggestionString, template };
+    }
+}
+/**
+ * A custom form element for search inputs.
+ */
+export class SearchInputComponent {
+    constructor() {
+        /**
+         * the querrry was changed, update the suggetion list
+         */
+        this.fngChange = new EventEmitter();
+        /**
+         * Start search on this event
+         */
+        this.fngSearch = new EventEmitter();
+        /**
+         * The search input label.
+         */
+        this.label = '';
+        this.innerDisabled = false;
+        this.innerValue = '';
+        this.innerSuggestions = [];
+        this.hideSuggestionList = false;
+        // This is the index of the selected element in dhe suggestion list.
+        this.selectedSuggestionIndex = -1;
+    }
+    /**
+     * When true the control's disabled attribute is set
+     * and it gets addeed the .disabled css class.
+     */
+    get disabled() {
+        return this.innerDisabled;
+    }
+    set disabled(value) {
+        this.innerDisabled = coerceBooleanProperty(value);
+    }
+    /**
+     * The getter for value.
+     */
+    get value() {
+        return this.innerValue;
+    }
+    /**
+     * The setter for value.
+     */
+    set value(value) {
+        if (value != null) {
+            value = '' + value;
+        }
+        this.innerValue = value;
+    }
+    /**
+     * The list of suggestions
+     */
+    set suggestions(value) {
+        this.selectedSuggestionIndex = -1;
+        this.innerSuggestions = value;
+    }
+    /**
+     * The list of suggestions capped by 10 entries
+     */
+    get cappedSuggestions() {
+        return this.innerSuggestions.slice(0, 10);
+    }
+    keyhandler(event) {
+        if (!this.cappedSuggestions || !this.cappedSuggestions.length) {
+            return;
+        }
+        // navigate inside the suggestion list
+        if (event.key === 'ArrowUp') {
+            if (this.selectedSuggestionIndex > 0) {
+                this.selectedSuggestionIndex--;
+            }
+            else {
+                this.selectedSuggestionIndex = this.cappedSuggestions.length - 1;
+            }
+            this.value = this.cappedSuggestions[this.selectedSuggestionIndex].value;
+        }
+        if (event.key === 'ArrowDown') {
+            if (this.selectedSuggestionIndex >= this.cappedSuggestions.length - 1) {
+                this.selectedSuggestionIndex = 0;
+            }
+            else {
+                this.selectedSuggestionIndex++;
+            }
+            this.value = this.cappedSuggestions[this.selectedSuggestionIndex].value;
+        }
+    }
+    onClickOutside() {
+        this.hideSuggestionList = true;
+    }
+    onFocus() {
+        this.hideSuggestionList = false;
+    }
+    onInput(event) {
+        this.selectedSuggestionIndex = -1;
+        this.value = event.target.value;
+        this.fngChange.emit(this.value);
+    }
+    // also triggert on "Enter" and "Escape"
+    onSearch(event) {
+        event.stopPropagation();
+        this.selectedSuggestionIndex = -1;
+        this.fngSearch.emit(this.value);
+        this.hideSuggestionList = true;
+        this.inputRef.nativeElement.blur();
+    }
+    onSuggestionClick(suggestion) {
+        this.selectedSuggestionIndex = -1;
+        this.value = suggestion.value;
+        this.fngSearch.emit(this.value);
+        this.hideSuggestionList = true;
+        this.inputRef.nativeElement.blur();
+    }
+    clearQuery() {
+        this.selectedSuggestionIndex = -1;
+        this.value = '';
+        this.fngSearch.emit(this.value);
+        this.hideSuggestionList = true;
+        this.inputRef.nativeElement.blur();
+    }
+}
+SearchInputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SearchInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SearchInputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: SearchInputComponent, selector: "fng-search-input", inputs: { label: "label", disabled: "disabled", value: "value", suggestions: "suggestions" }, outputs: { fngChange: "fngChange", fngSearch: "fngSearch" }, host: { listeners: { "document:keydown": "keyhandler($event)" } }, viewQueries: [{ propertyName: "inputRef", first: true, predicate: ["inputElement"], descendants: true }], ngImport: i0, template: "<div class=\"fwe-search-input fwe-w-100\" (clickOutside)=\"onClickOutside()\" fngClickOutside>\n  <input\n    class=\"fwe-w-100\"\n    #inputElement\n    [attr.disabled]=\"disabled ? '' : null\"\n    [placeholder]=\"label\"\n    (focus)=\"onFocus()\"\n    type=\"search\"\n    (input)=\"onInput($event)\"\n    (search)=\"onSearch($event)\"\n    [value]=\"innerValue\"\n  />\n  <div class=\"fwe-search-icon\"></div>\n  <div class=\"fwe-clear-icon\" (click)=\"clearQuery()\"></div>\n  <div class=\"fwe-search-suggestions\" *ngIf=\"innerSuggestions?.length && !hideSuggestionList\">\n    <div\n      *ngFor=\"let suggestion of cappedSuggestions; let i = index\"\n      (click)=\"onSuggestionClick(suggestion)\"\n      [class.fwe-selected]=\"selectedSuggestionIndex === i\"\n      class=\"fwe-search-suggestion\"\n    >\n      <div [innerHTML]=\"suggestion.template | safeHtml\"></div>\n    </div>\n    <div class=\"fwe-ml-xxs\" *ngIf=\"innerSuggestions.length > 10\">...</div>\n  </div>\n</div>\n", styles: [".fwe-w-100{width:100%}.fwe-search-suggestion{height:40px}\n"], directives: [{ type: i1.ClickOutsideDirective, selector: "[fngClickOutside]", outputs: ["clickOutside"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "safeHtml": i3.SafeHtmlPipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SearchInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fng-search-input', encapsulation: ViewEncapsulation.None, template: "<div class=\"fwe-search-input fwe-w-100\" (clickOutside)=\"onClickOutside()\" fngClickOutside>\n  <input\n    class=\"fwe-w-100\"\n    #inputElement\n    [attr.disabled]=\"disabled ? '' : null\"\n    [placeholder]=\"label\"\n    (focus)=\"onFocus()\"\n    type=\"search\"\n    (input)=\"onInput($event)\"\n    (search)=\"onSearch($event)\"\n    [value]=\"innerValue\"\n  />\n  <div class=\"fwe-search-icon\"></div>\n  <div class=\"fwe-clear-icon\" (click)=\"clearQuery()\"></div>\n  <div class=\"fwe-search-suggestions\" *ngIf=\"innerSuggestions?.length && !hideSuggestionList\">\n    <div\n      *ngFor=\"let suggestion of cappedSuggestions; let i = index\"\n      (click)=\"onSuggestionClick(suggestion)\"\n      [class.fwe-selected]=\"selectedSuggestionIndex === i\"\n      class=\"fwe-search-suggestion\"\n    >\n      <div [innerHTML]=\"suggestion.template | safeHtml\"></div>\n    </div>\n    <div class=\"fwe-ml-xxs\" *ngIf=\"innerSuggestions.length > 10\">...</div>\n  </div>\n</div>\n", styles: [".fwe-w-100{width:100%}.fwe-search-suggestion{height:40px}\n"] }]
+        }], propDecorators: { inputRef: [{
+                type: ViewChild,
+                args: ['inputElement']
+            }], fngChange: [{
+                type: Output
+            }], fngSearch: [{
+                type: Output
+            }], label: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], suggestions: [{
+                type: Input
+            }], keyhandler: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-input.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/src/lib/components/search-input/search-input.component.ts","../../../../../../../libs/angular/src/lib/components/search-input/search-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ViewChild, ElementRef, ViewEncapsulation, Output, EventEmitter, HostListener } from '@angular/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\nexport class SearchSuggestion {\n  /**\n   * a html-string. e.g.: '<b> hello </b>'\n   */\n  template: string;\n\n  /**\n   * This Value will be used as new query when the user selects the suggestion.\n   */\n  value: string;\n\n  /**\n   * Creates a basic Suggestion from a string. The first query match is highlighted by bold tags.\n   * @param suggestionString The suggested string (should contain the whole query)\n   * @param query The current query. This string will be highlighted.\n   * @returns a html-string.\n   */\n  static basicSuggestion(suggestionString: string, query: string): SearchSuggestion {\n    const i = suggestionString.toLocaleLowerCase().indexOf(query.toLocaleLowerCase());\n    let template = suggestionString;\n    if (i != -1) {\n      const  boldStart = i;\n      const boldEnd = i + query.length;\n      const part1 = suggestionString.substring(0, boldStart);\n      const part2 = suggestionString.substring(boldStart, boldEnd);\n      const part3 = suggestionString.substring(boldEnd, suggestionString.length);\n      template = part1 + '<b>' + part2 + '</b>' + part3;\n    }\n    return { value: suggestionString, template };\n  }\n}\n\n/**\n * A custom form element for search inputs.\n */\n@Component({\n  selector: 'fng-search-input',\n  templateUrl: './search-input.component.html',\n  styleUrls: ['./search-input.component.scss'],\n  encapsulation: ViewEncapsulation.None\n})\nexport class SearchInputComponent {\n  @ViewChild('inputElement')\n  inputRef!: ElementRef<HTMLInputElement>;\n\n  /**\n   * the querrry was changed, update the suggetion list\n   */\n  @Output()\n  readonly fngChange = new EventEmitter<string>();\n\n  /**\n   * Start search on this event\n   */\n  @Output()\n  readonly fngSearch = new EventEmitter<string>();\n\n  /**\n   * The search input label.\n   */\n  @Input() label: string = '';\n\n  /**\n   * When true the control's disabled attribute is set\n   * and it gets addeed the .disabled css class.\n   */\n  @Input()\n  get disabled(): boolean {\n    return this.innerDisabled;\n  }\n  set disabled(value: boolean) {\n    this.innerDisabled = coerceBooleanProperty(value);\n  }\n  protected innerDisabled = false;\n\n  innerValue: string = '';\n\n  /**\n   * The getter for value.\n   */\n  get value(): string {\n    return this.innerValue;\n  }\n\n  /**\n   * The setter for value.\n   */\n  @Input()\n  set value(value: string) {\n    if (value != null) {\n      value = '' + value;\n    }\n    this.innerValue = value;\n  }\n\n  /**\n   * The list of suggestions\n   */\n  @Input()\n  set suggestions(value: SearchSuggestion[]) {\n    this.selectedSuggestionIndex = -1;\n    this.innerSuggestions = value;\n  }\n\n  /**\n   * The list of suggestions capped by 10 entries\n   */\n  get cappedSuggestions(): SearchSuggestion[] {\n    return this.innerSuggestions.slice(0, 10);\n  }\n\n  innerSuggestions: SearchSuggestion[] = [];\n  hideSuggestionList: boolean = false;\n\n  // This is the index of the selected element in dhe suggestion list.\n  selectedSuggestionIndex = -1;\n\n  @HostListener('document:keydown', ['$event'])\n  keyhandler(event: KeyboardEvent) {\n    if (!this.cappedSuggestions || !this.cappedSuggestions.length) {\n      return;\n    }\n\n    // navigate inside the suggestion list\n    if (event.key === 'ArrowUp') {\n      if (this.selectedSuggestionIndex > 0) {\n        this.selectedSuggestionIndex--;\n      } else {\n        this.selectedSuggestionIndex = this.cappedSuggestions.length - 1;\n      }\n      this.value = this.cappedSuggestions[this.selectedSuggestionIndex].value;\n    }\n\n    if (event.key === 'ArrowDown') {\n      if (this.selectedSuggestionIndex >= this.cappedSuggestions.length - 1) {\n        this.selectedSuggestionIndex = 0;\n      } else {\n        this.selectedSuggestionIndex++;\n      }\n      this.value = this.cappedSuggestions[this.selectedSuggestionIndex].value;\n    }\n  }\n\n  onClickOutside(): void {\n    this.hideSuggestionList = true;\n  }\n\n  onFocus() {\n    this.hideSuggestionList = false;\n  }\n\n  onInput(event: any) {\n    this.selectedSuggestionIndex = -1;\n    this.value = event.target.value;\n    this.fngChange.emit(this.value);\n  }\n\n  // also triggert on \"Enter\" and \"Escape\"\n  onSearch(event: any): void {\n    event.stopPropagation();\n    this.selectedSuggestionIndex = -1;\n    this.fngSearch.emit(this.value);\n    this.hideSuggestionList = true;\n    this.inputRef.nativeElement.blur();\n  }\n\n  onSuggestionClick(suggestion: SearchSuggestion) {\n    this.selectedSuggestionIndex = -1;\n    this.value = suggestion.value;\n    this.fngSearch.emit(this.value);\n    this.hideSuggestionList = true;\n    this.inputRef.nativeElement.blur();\n  }\n\n  clearQuery(): void {\n    this.selectedSuggestionIndex = -1;\n    this.value = '';\n    this.fngSearch.emit(this.value);\n    this.hideSuggestionList = true;\n    this.inputRef.nativeElement.blur();\n  }\n}\n","<div class=\"fwe-search-input fwe-w-100\" (clickOutside)=\"onClickOutside()\" fngClickOutside>\n  <input\n    class=\"fwe-w-100\"\n    #inputElement\n    [attr.disabled]=\"disabled ? '' : null\"\n    [placeholder]=\"label\"\n    (focus)=\"onFocus()\"\n    type=\"search\"\n    (input)=\"onInput($event)\"\n    (search)=\"onSearch($event)\"\n    [value]=\"innerValue\"\n  />\n  <div class=\"fwe-search-icon\"></div>\n  <div class=\"fwe-clear-icon\" (click)=\"clearQuery()\"></div>\n  <div class=\"fwe-search-suggestions\" *ngIf=\"innerSuggestions?.length && !hideSuggestionList\">\n    <div\n      *ngFor=\"let suggestion of cappedSuggestions; let i = index\"\n      (click)=\"onSuggestionClick(suggestion)\"\n      [class.fwe-selected]=\"selectedSuggestionIndex === i\"\n      class=\"fwe-search-suggestion\"\n    >\n      <div [innerHTML]=\"suggestion.template | safeHtml\"></div>\n    </div>\n    <div class=\"fwe-ml-xxs\" *ngIf=\"innerSuggestions.length > 10\">...</div>\n  </div>\n</div>\n"]}

package/esm2020/lib/components/snackbar/snackbar-container.component.mjs

@@ -0,0 +1,21 @@
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./snackbar-container.directive";
+export class SnackbarContainerComponent {
+    constructor() {
+        this.config = {
+            darkBackground: true,
+            disappearAfter: 5000,
+            closeOnAction: true
+        };
+    }
+}
+SnackbarContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SnackbarContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SnackbarContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: SnackbarContainerComponent, selector: "fng-snackbar-container", inputs: { config: "config" }, ngImport: i0, template: "<div class=\"fwe-snackbar-container\">\n  <div [fngSnackbarContainer]=\"config\"></div>\n</div>\n", styles: [".fwe-snackbar-container{pointer-events:none}\n"], directives: [{ type: i1.SnackbarContainerDirective, selector: "[fngSnackbarContainer]", inputs: ["fngSnackbarContainer"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SnackbarContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fng-snackbar-container', encapsulation: ViewEncapsulation.None, template: "<div class=\"fwe-snackbar-container\">\n  <div [fngSnackbarContainer]=\"config\"></div>\n</div>\n", styles: [".fwe-snackbar-container{pointer-events:none}\n"] }]
+        }], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2tiYXItY29udGFpbmVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9zcmMvbGliL2NvbXBvbmVudHMvc25hY2tiYXIvc25hY2tiYXItY29udGFpbmVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9zcmMvbGliL2NvbXBvbmVudHMvc25hY2tiYXIvc25hY2tiYXItY29udGFpbmVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFTcEUsTUFBTSxPQUFPLDBCQUEwQjtJQU52QztRQU9XLFdBQU0sR0FBbUI7WUFDaEMsY0FBYyxFQUFFLElBQUk7WUFDcEIsY0FBYyxFQUFFLElBQUk7WUFDcEIsYUFBYSxFQUFFLElBQUk7U0FDcEIsQ0FBQztLQUNIOzt1SEFOWSwwQkFBMEI7MkdBQTFCLDBCQUEwQiw0RkNUdkMsbUdBR0E7MkZETWEsMEJBQTBCO2tCQU50QyxTQUFTOytCQUNFLHdCQUF3QixpQkFHbkIsaUJBQWlCLENBQUMsSUFBSTs4QkFHNUIsTUFBTTtzQkFBZCxLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgVmlld0VuY2Fwc3VsYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFNuYWNrYmFyQ29uZmlnIH0gZnJvbSAnLi9zbmFja2Jhci5tb2RlbHMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdmbmctc25hY2tiYXItY29udGFpbmVyJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3NuYWNrYmFyLWNvbnRhaW5lci5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3NuYWNrYmFyLWNvbnRhaW5lci5jb21wb25lbnQuc2NzcyddLFxuICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lXG59KVxuZXhwb3J0IGNsYXNzIFNuYWNrYmFyQ29udGFpbmVyQ29tcG9uZW50IHtcbiAgQElucHV0KCkgY29uZmlnOiBTbmFja2JhckNvbmZpZyA9IHtcbiAgICBkYXJrQmFja2dyb3VuZDogdHJ1ZSxcbiAgICBkaXNhcHBlYXJBZnRlcjogNTAwMCxcbiAgICBjbG9zZU9uQWN0aW9uOiB0cnVlXG4gIH07XG59XG4iLCI8ZGl2IGNsYXNzPVwiZndlLXNuYWNrYmFyLWNvbnRhaW5lclwiPlxuICA8ZGl2IFtmbmdTbmFja2JhckNvbnRhaW5lcl09XCJjb25maWdcIj48L2Rpdj5cbjwvZGl2PlxuIl19