@colijnit/corecomponents_v12 12.2.25 → 12.2.27

package/esm2015/lib/directives/ripple/scroll-dispatcher.service.js

@@ -0,0 +1,108 @@
+// NOTE: Copied and adapted to iOneJS from https://github.com/angular/material2/blob/master/src/lib/core on 14-march-2017.
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { fromEvent, merge, Subject } from 'rxjs';
+import { auditTime } from 'rxjs/operators';
+/** Time in ms to throttle the scrolling events by default. */
+export const DEFAULT_SCROLL_TIME = 20;
+/**
+ * Service contained all registered Scrollable references and emits an event when any one of the
+ * Scrollable references emit a scrolled event.
+ */
+export class CoScrollDispatcherService {
+    constructor() {
+        /** Subject for notifying that a registered scrollable reference element has been scrolled. */
+        this._scrolled = new Subject();
+        /** Keeps track of the global `scroll` and `resize` subscriptions. */
+        this._globalSubscription = null;
+        /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */
+        this._scrolledCount = 0;
+        /**
+         * Map of all the scrollable references that are registered with the service and their
+         * scroll event subscriptions.
+         */
+        this.scrollableReferences = new Map();
+    }
+    /**
+     * Registers a Scrollable with the service and listens for its scrolled events. When the
+     * scrollable is scrolled, the service emits the event in its scrolled observable.
+     * @param scrollable Scrollable instance to be registered.
+     */
+    register(scrollable) {
+        const scrollSubscription = scrollable.elementScrolled().subscribe(() => this._notify());
+        this.scrollableReferences.set(scrollable, scrollSubscription);
+    }
+    /**
+     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.
+     * @param scrollable Scrollable instance to be deregistered.
+     */
+    deregister(scrollable) {
+        if (this.scrollableReferences.has(scrollable)) {
+            this.scrollableReferences.get(scrollable).unsubscribe();
+            this.scrollableReferences.delete(scrollable);
+        }
+    }
+    /**
+     * Subscribes to an observable that emits an event whenever any of the registered Scrollable
+     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms
+     * to override the default "throttle" time.
+     */
+    scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME, callback) {
+        // In the case of a 0ms delay, use an observable without auditTime
+        // since it does add a perceptible delay in processing overhead.
+        let observable = auditTimeInMs > 0 ?
+            auditTime(auditTimeInMs) :
+            this._scrolled.asObservable();
+        this._scrolledCount++;
+        if (!this._globalSubscription) {
+            this._globalSubscription = merge(fromEvent(window.document, 'scroll'), fromEvent(window, 'resize')).subscribe(() => this._notify());
+        }
+        // Note that we need to do the subscribing from here, in order to be able to remove
+        // the global event listeners once there are no more subscriptions.
+        return observable.subscribe(callback).add(() => {
+            this._scrolledCount--;
+            if (this._globalSubscription && !this.scrollableReferences.size && !this._scrolledCount) {
+                this._globalSubscription.unsubscribe();
+                this._globalSubscription = null;
+            }
+        });
+    }
+    /** Returns all registered Scrollables that contain the provided element. */
+    getScrollContainers(elementRef) {
+        const scrollingContainers = [];
+        this.scrollableReferences.forEach((subscription, scrollable) => {
+            if (this.scrollableContainsElement(scrollable, elementRef)) {
+                scrollingContainers.push(scrollable);
+            }
+        });
+        return scrollingContainers;
+    }
+    /** Returns true if the element is contained within the provided Scrollable. */
+    scrollableContainsElement(scrollable, elementRef) {
+        let element = elementRef.nativeElement;
+        let scrollableElement = scrollable.getElementRef().nativeElement;
+        // Traverse through the element parents until we reach null, checking if any of the elements
+        // are the scrollable's element.
+        do {
+            if (element == scrollableElement) {
+                return true;
+            }
+        } while (element = element.parentElement);
+    }
+    /** Sends a notification that a scroll event has been fired. */
+    _notify() {
+        this._scrolled.next();
+    }
+}
+CoScrollDispatcherService.decorators = [
+    { type: Injectable }
+];
+export function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher) {
+    return parentDispatcher || new CoScrollDispatcherService();
+}
+export const SCROLL_DISPATCHER_PROVIDER = {
+    // If there is already a ScrollDispatcher available, use that. Otherwise, provide a new one.
+    provide: CoScrollDispatcherService,
+    deps: [[new Optional(), new SkipSelf(), CoScrollDispatcherService]],
+    useFactory: SCROLL_DISPATCHER_PROVIDER_FACTORY
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-dispatcher.service.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/ripple/scroll-dispatcher.service.ts"],"names":[],"mappings":"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","sourcesContent":["// NOTE: Copied and adapted to iOneJS from https://github.com/angular/material2/blob/master/src/lib/core on 14-march-2017.\r\nimport { ElementRef, Injectable, Optional, SkipSelf } from '@angular/core';\r\nimport { fromEvent, merge, Observable, Subject, Subscription } from 'rxjs';\r\n\r\nimport { CoScrollableDirective } from './scrollable.directive';\r\nimport { auditTime } from 'rxjs/operators';\r\n\r\n/** Time in ms to throttle the scrolling events by default. */\r\nexport const DEFAULT_SCROLL_TIME = 20;\r\n\r\n/**\r\n * Service contained all registered Scrollable references and emits an event when any one of the\r\n * Scrollable references emit a scrolled event.\r\n */\r\n@Injectable()\r\nexport class CoScrollDispatcherService {\r\n    /** Subject for notifying that a registered scrollable reference element has been scrolled. */\r\n    _scrolled: Subject<void> = new Subject<void>();\r\n\r\n    /** Keeps track of the global `scroll` and `resize` subscriptions. */\r\n    _globalSubscription: Subscription = null;\r\n\r\n    /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */\r\n    private _scrolledCount = 0;\r\n\r\n    /**\r\n     * Map of all the scrollable references that are registered with the service and their\r\n     * scroll event subscriptions.\r\n     */\r\n    scrollableReferences: Map<CoScrollableDirective, Subscription> = new Map();\r\n\r\n    /**\r\n     * Registers a Scrollable with the service and listens for its scrolled events. When the\r\n     * scrollable is scrolled, the service emits the event in its scrolled observable.\r\n     * @param scrollable Scrollable instance to be registered.\r\n     */\r\n    register(scrollable: CoScrollableDirective): void {\r\n        const scrollSubscription = scrollable.elementScrolled().subscribe(() => this._notify());\r\n\r\n        this.scrollableReferences.set(scrollable, scrollSubscription);\r\n    }\r\n\r\n    /**\r\n     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.\r\n     * @param scrollable Scrollable instance to be deregistered.\r\n     */\r\n    deregister(scrollable: CoScrollableDirective): void {\r\n        if (this.scrollableReferences.has(scrollable)) {\r\n            this.scrollableReferences.get(scrollable).unsubscribe();\r\n            this.scrollableReferences.delete(scrollable);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Subscribes to an observable that emits an event whenever any of the registered Scrollable\r\n     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms\r\n     * to override the default \"throttle\" time.\r\n     */\r\n    scrolled(auditTimeInMs: number = DEFAULT_SCROLL_TIME, callback: () => any): Subscription {\r\n        // In the case of a 0ms delay, use an observable without auditTime\r\n        // since it does add a perceptible delay in processing overhead.\r\n        let observable: any = auditTimeInMs > 0 ?\r\n            auditTime(auditTimeInMs) :\r\n            this._scrolled.asObservable();\r\n\r\n        this._scrolledCount++;\r\n\r\n        if (!this._globalSubscription) {\r\n            this._globalSubscription = merge(\r\n                fromEvent(window.document, 'scroll'),\r\n                fromEvent(window, 'resize')\r\n            ).subscribe(() => this._notify());\r\n        }\r\n\r\n        // Note that we need to do the subscribing from here, in order to be able to remove\r\n        // the global event listeners once there are no more subscriptions.\r\n        return observable.subscribe(callback).add(() => {\r\n            this._scrolledCount--;\r\n\r\n            if (this._globalSubscription && !this.scrollableReferences.size && !this._scrolledCount) {\r\n                this._globalSubscription.unsubscribe();\r\n                this._globalSubscription = null;\r\n            }\r\n        });\r\n    }\r\n\r\n    /** Returns all registered Scrollables that contain the provided element. */\r\n    getScrollContainers(elementRef: ElementRef): CoScrollableDirective[] {\r\n        const scrollingContainers: CoScrollableDirective[] = [];\r\n\r\n        this.scrollableReferences.forEach((subscription: Subscription, scrollable: CoScrollableDirective) => {\r\n            if (this.scrollableContainsElement(scrollable, elementRef)) {\r\n                scrollingContainers.push(scrollable);\r\n            }\r\n        });\r\n\r\n        return scrollingContainers;\r\n    }\r\n\r\n    /** Returns true if the element is contained within the provided Scrollable. */\r\n    scrollableContainsElement(scrollable: CoScrollableDirective, elementRef: ElementRef): boolean {\r\n        let element = elementRef.nativeElement;\r\n        let scrollableElement = scrollable.getElementRef().nativeElement;\r\n\r\n        // Traverse through the element parents until we reach null, checking if any of the elements\r\n        // are the scrollable's element.\r\n        do {\r\n            if (element == scrollableElement) {\r\n                return true;\r\n            }\r\n        } while (element = element.parentElement);\r\n    }\r\n\r\n    /** Sends a notification that a scroll event has been fired. */\r\n    _notify() {\r\n        this._scrolled.next();\r\n    }\r\n}\r\n\r\nexport function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher: CoScrollDispatcherService) {\r\n    return parentDispatcher || new CoScrollDispatcherService();\r\n}\r\n\r\nexport const SCROLL_DISPATCHER_PROVIDER = {\r\n    // If there is already a ScrollDispatcher available, use that. Otherwise, provide a new one.\r\n    provide: CoScrollDispatcherService,\r\n    deps: [[new Optional(), new SkipSelf(), CoScrollDispatcherService]],\r\n    useFactory: SCROLL_DISPATCHER_PROVIDER_FACTORY\r\n};\r\n"]}

package/esm2015/lib/directives/ripple/scrollable.directive.js

@@ -0,0 +1,40 @@
+// NOTE: Copied and adapted to TwoDSelector from iOneJS on 9-may-2018.
+import { Directive, ElementRef } from '@angular/core';
+import { CoScrollDispatcherService } from './scroll-dispatcher.service';
+import { fromEvent } from 'rxjs';
+/**
+ * Sends an event when the directive's element is scrolled. Registers itself with the
+ * ScrollDispatcher service to include itself as part of its collection of scrolling events that it
+ * can be listened to through the service.
+ */
+export class CoScrollableDirective {
+    constructor(_elementRef, _scroll) {
+        this._elementRef = _elementRef;
+        this._scroll = _scroll;
+    }
+    ngOnInit() {
+        this._scroll.register(this);
+    }
+    ngOnDestroy() {
+        this._scroll.deregister(this);
+    }
+    /**
+     * Returns observable that emits when a scroll event is fired on the host element.
+     */
+    elementScrolled() {
+        return fromEvent(this._elementRef.nativeElement, 'scroll');
+    }
+    getElementRef() {
+        return this._elementRef;
+    }
+}
+CoScrollableDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdk-scrollable]'
+            },] }
+];
+CoScrollableDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: CoScrollDispatcherService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/ripple/viewport-ruler.service.js

@@ -0,0 +1,73 @@
+// NOTE: Copied and adapted to TwoDSelector from iOneJS on 9-may-2018.
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { CoScrollDispatcherService } from "./scroll-dispatcher.service";
+/**
+ * Simple utility for getting the bounds of the browser viewport.
+ * @docs-private
+ */
+export class CoViewportRulerService {
+    constructor(scrollDispatcher) {
+        // Initially cache the document rectangle.
+        this._cacheViewportGeometry();
+        // Subscribe to scroll and resize events and update the document rectangle on changes.
+        scrollDispatcher.scrolled(null, () => this._cacheViewportGeometry());
+    }
+    /** Gets a ClientRect for the viewport's bounds. */
+    getViewportRect(documentRect = this._documentRect) {
+        // Use the document element's bounding rect rather than the window scroll properties
+        // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll
+        // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different
+        // conceptual viewports. Under most circumstances these viewports are equivalent, but they
+        // can disagree when the page is pinch-zoomed (on devices that support touch).
+        // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4
+        // We use the documentElement instead of the body because, by default (without a css reset)
+        // browsers typically give the document body an 8px margin, which is not included in
+        // getBoundingClientRect().
+        const scrollPosition = this.getViewportScrollPosition(documentRect);
+        const height = window.innerHeight;
+        const width = window.innerWidth;
+        return {
+            top: scrollPosition.top,
+            left: scrollPosition.left,
+            bottom: scrollPosition.top + height,
+            right: scrollPosition.left + width,
+            height,
+            width,
+        };
+    }
+    /**
+     * Gets the (top, left) scroll position of the viewport.
+     * @param documentRect
+     */
+    getViewportScrollPosition(documentRect = this._documentRect) {
+        // The top-left-corner of the viewport is determined by the scroll position of the document
+        // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about
+        // whether `document.body` or `document.documentElement` is the scrolled element, so reading
+        // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of
+        // `document.documentElement` works consistently, where the `top` and `left` values will
+        // equal negative the scroll position.
+        const top = -documentRect.top || document.body.scrollTop || window.scrollY || 0;
+        const left = -documentRect.left || document.body.scrollLeft || window.scrollX || 0;
+        return { top, left };
+    }
+    /** Caches the latest client rectangle of the document element. */
+    _cacheViewportGeometry() {
+        this._documentRect = document.documentElement.getBoundingClientRect();
+    }
+}
+CoViewportRulerService.decorators = [
+    { type: Injectable }
+];
+CoViewportRulerService.ctorParameters = () => [
+    { type: CoScrollDispatcherService }
+];
+export function VIEWPORT_RULER_PROVIDER_FACTORY(parentRuler, scrollDispatcher) {
+    return parentRuler || new CoViewportRulerService(scrollDispatcher);
+}
+export const VIEWPORT_RULER_PROVIDER = {
+    // If there is already a ViewportRuler available, use that. Otherwise, provide a new one.
+    provide: CoViewportRulerService,
+    deps: [[new Optional(), new SkipSelf(), CoViewportRulerService], CoScrollDispatcherService],
+    useFactory: VIEWPORT_RULER_PROVIDER_FACTORY
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/screen-configuration/screen-configuration.directive.js

@@ -0,0 +1,158 @@
+import { __decorate } from "tslib";
+import { Directive, ElementRef, Inject, Input, Renderer2 } from '@angular/core';
+import { InputBoolean } from '../../core/decorator/input-boolean.decorator';
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from '../../interfaces/screen-config-adapter-component-interface-name';
+import { BaseModuleScreenConfigService } from '../../service/base-module-screen-config.service';
+import { BaseModuleService } from '../../service/base-module.service';
+// Directive to represents the marker of "screen config name ID's" of components within a module.
+// Manipulates visibility, readonly and other dynamic states of an input element according to its db-fetched screen configuration object.
+export class ScreenConfigurationDirective {
+    constructor(hostComponent, _element, 
+    // we must always have a config service to fetch config objects with
+    _configService, _renderer, 
+    // to make host readonly when MODULE switches to readonly:
+    _moduleService) {
+        this.hostComponent = hostComponent;
+        this._element = _element;
+        this._configService = _configService;
+        this._renderer = _renderer;
+        this._moduleService = _moduleService;
+        this.screenConfigNativeElement = false;
+        this.noModuleService = false;
+        // feature toggle for devs so you can see the whole screen with all inputs etc by temporarily turning off the hiding effects of this directive on its host
+        this._isTurnedOff = false;
+        this._subs = [];
+        this._subs.push(this._configService.configSet.subscribe((configObjects) => {
+            if (configObjects && configObjects.length > 0) {
+                this._updateHost();
+            }
+        }));
+        if (this._moduleService && !this.noModuleService) {
+            this._subs.push(this._moduleService.readonlyChange.subscribe((moduleInReadonlyState) => {
+                if (this.hostComponent) {
+                    this.hostComponent.readonly = this.hostComponent.forceReadonly || moduleInReadonlyState;
+                }
+            }), this._moduleService.errorValidationReceived.subscribe((validationResult) => {
+                this._setErrorRedBackgroundAfterScrCfgValidate(validationResult);
+            }), this._moduleService.successfulUpdate.subscribe(() => {
+                if (this.hostComponent) {
+                    this.hostComponent.redErrorBackground = false;
+                }
+            }));
+        }
+    }
+    set screenConfigurationObject(value) {
+        if (value) {
+            this._screenConfigurationObject = value;
+            this._updateHost();
+        }
+    }
+    get screenConfigurationObject() {
+        return this._screenConfigurationObject;
+    }
+    ngOnInit() {
+        this._updateHost();
+        // this._updateHeaderStateOnHostComponent(true);
+        // show initial error message if any
+        if (!this.noModuleService) {
+            // this._setErrorRedBackgroundAfterScrCfgValidate(this._moduleService.lastError);
+        }
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+        if (this._isHeader) {
+            // this._doubleClickHeaders.handleCollapseableDestroy(this.screenConfigurationObject);
+        }
+        this._element = undefined;
+        this.hostComponent = undefined;
+    }
+    // Sets host component visibility, required, readonly etc. if specified in backend screen config OR module readonly status.
+    _updateHost() {
+        if (this._mayUpdateHost() || this.screenConfigNativeElement) {
+            if (!this.screenConfigNativeElement) {
+                this.hostComponent.objectConfigName = this.screenConfigurationObject;
+            }
+            const myCfgObj = this._configService.getObjectConfigurationFor(this.screenConfigurationObject);
+            if (myCfgObj) {
+                this._setHostVisible(myCfgObj.immediatelyVisible());
+                // if (this.hostComponent instanceof GridColumnComponent) {
+                //   this.hostComponent.rights = myCfgObj.rights;
+                // }
+                if (!this.screenConfigNativeElement) {
+                    this.hostComponent.required = myCfgObj.isRequired();
+                    this.hostComponent.readonly = this.hostComponent.forceReadonly || this._moduleInReadonlyMode() || myCfgObj.isReadonly();
+                    this.hostComponent.decimals = myCfgObj.scale;
+                    this.hostComponent.maxLength = myCfgObj.maxLength;
+                }
+            }
+            else {
+                this._setHostVisible(false);
+                if (!this.screenConfigNativeElement) {
+                    this.hostComponent.readonly = this._moduleInReadonlyMode();
+                }
+            }
+        }
+    }
+    /**
+     * Spawn error message tooltip onto our host comp, if any error was meant for the host (found by screenConfigurationObject);
+     * @param errorValidation A top-level full validation result, either from the backend or from some client-side validation error.
+     */
+    _setErrorRedBackgroundAfterScrCfgValidate(errorValidation) {
+        if (this.hostComponent && errorValidation) {
+            const errorMessages = errorValidation.getAllErrorMessagesOfMyValidationFields();
+            for (let i = 0, len = errorMessages.length; i < len; i++) {
+                const errorMsg = errorMessages[i];
+                const configName = this.dataName ? this.dataName : this.screenConfigurationObject;
+                if (errorMsg.fieldId === configName && this._element /*&& this._properHost(errorMsg.boId)*/) {
+                    this.hostComponent.redErrorBackground = true;
+                }
+            }
+        }
+    }
+    _moduleInReadonlyMode() {
+        return !this.noModuleService ? (this._moduleService ? this._moduleService.readonly : false) : false;
+    }
+    _mayUpdateHost() {
+        return !!this.hostComponent && !this._isTurnedOff && !!this.screenConfigurationObject;
+    }
+    _setHostVisible(visible) {
+        if (!this.screenConfigNativeElement) {
+            this.hostComponent.hidden = !visible;
+        }
+        else {
+            if (this._element && this._element.nativeElement) {
+                if (!visible) {
+                    this._renderer.addClass(this._element.nativeElement, 'hidden');
+                }
+                else {
+                    this._renderer.removeClass(this._element.nativeElement, 'hidden');
+                }
+            }
+        }
+    }
+}
+ScreenConfigurationDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[screenConfigurationObject]'
+            },] }
+];
+ScreenConfigurationDirective.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,] }] },
+    { type: ElementRef },
+    { type: BaseModuleScreenConfigService },
+    { type: Renderer2 },
+    { type: BaseModuleService }
+];
+ScreenConfigurationDirective.propDecorators = {
+    screenConfigurationObject: [{ type: Input, args: ['screenConfigurationObject',] }],
+    dataName: [{ type: Input }],
+    screenConfigNativeElement: [{ type: Input }],
+    noModuleService: [{ type: Input }]
+};
+__decorate([
+    InputBoolean()
+], ScreenConfigurationDirective.prototype, "screenConfigNativeElement", void 0);
+__decorate([
+    InputBoolean()
+], ScreenConfigurationDirective.prototype, "noModuleService", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen-configuration.directive.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/screen-configuration/screen-configuration.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, Inject, Input, OnDestroy, Renderer2} from '@angular/core';\r\nimport {InputBoolean} from '../../core/decorator/input-boolean.decorator';\r\nimport {ScreenConfigAdapterComponent} from '../../interfaces/screen-config-adapter.component.interface';\r\nimport {SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME} from '../../interfaces/screen-config-adapter-component-interface-name';\r\nimport {Subscription} from 'rxjs';\r\nimport {BaseModuleScreenConfigService} from '../../service/base-module-screen-config.service';\r\nimport {BaseModuleService} from '../../service/base-module.service';\r\nimport {ValidationResult} from '@colijnit/ioneconnector/build/model/validation-result';\r\nimport {ValidationMessage} from '@colijnit/ioneconnector/build/model/validation-message';\r\nimport {ObjectConfiguration} from '@colijnit/ioneconnector/build/model/object-configuration';\r\n\r\n// Directive to represents the marker of \"screen config name ID's\" of components within a module.\r\n// Manipulates visibility, readonly and other dynamic states of an input element according to its db-fetched screen configuration object.\r\n@Directive({\r\n    selector: '[screenConfigurationObject]'\r\n})\r\nexport class ScreenConfigurationDirective implements OnDestroy {\r\n    @Input('screenConfigurationObject')\r\n    public set screenConfigurationObject(value: string) {\r\n        if (value) {\r\n            this._screenConfigurationObject = value;\r\n            this._updateHost();\r\n        }\r\n    }\r\n\r\n    public get screenConfigurationObject(): string {\r\n        return this._screenConfigurationObject;\r\n    }\r\n\r\n    @Input()\r\n    public dataName: string;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public screenConfigNativeElement: boolean = false;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public noModuleService: boolean = false;\r\n\r\n    private _isHeader: boolean;\r\n\r\n    private _screenConfigurationObject: string;\r\n\r\n    // feature toggle for devs so you can see the whole screen with all inputs etc by temporarily turning off the hiding effects of this directive on its host\r\n    private _isTurnedOff: boolean = false;\r\n\r\n    private _subs: Subscription[] = [];\r\n\r\n    constructor(\r\n        @Inject(SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME)\r\n        public hostComponent: ScreenConfigAdapterComponent,\r\n        private _element: ElementRef,\r\n        // we must always have a config service to fetch config objects with\r\n        private _configService: BaseModuleScreenConfigService,\r\n        private _renderer: Renderer2,\r\n        // to make host readonly when MODULE switches to readonly:\r\n        private _moduleService?: BaseModuleService\r\n    ) {\r\n        this._subs.push(this._configService.configSet.subscribe((configObjects: string[]) => {\r\n            if (configObjects && configObjects.length > 0) {\r\n                this._updateHost();\r\n            }\r\n        }));\r\n\r\n        if (this._moduleService && !this.noModuleService) {\r\n            this._subs.push(\r\n                this._moduleService.readonlyChange.subscribe((moduleInReadonlyState: boolean) => {\r\n                    if (this.hostComponent) {\r\n                        this.hostComponent.readonly = this.hostComponent.forceReadonly || moduleInReadonlyState;\r\n                    }\r\n                }),\r\n                this._moduleService.errorValidationReceived.subscribe((validationResult: any) => {\r\n                    this._setErrorRedBackgroundAfterScrCfgValidate(validationResult);\r\n                }),\r\n                this._moduleService.successfulUpdate.subscribe(() => {\r\n                    if (this.hostComponent) {\r\n                        this.hostComponent.redErrorBackground = false;\r\n                    }\r\n                })\r\n            );\r\n        }\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this._updateHost();\r\n\r\n        // this._updateHeaderStateOnHostComponent(true);\r\n\r\n        // show initial error message if any\r\n        if (!this.noModuleService) {\r\n            // this._setErrorRedBackgroundAfterScrCfgValidate(this._moduleService.lastError);\r\n        }\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._subs.forEach(sub => sub.unsubscribe());\r\n        if (this._isHeader) {\r\n            // this._doubleClickHeaders.handleCollapseableDestroy(this.screenConfigurationObject);\r\n        }\r\n        this._element = undefined;\r\n        this.hostComponent = undefined;\r\n    }\r\n\r\n    // Sets host component visibility, required, readonly etc. if specified in backend screen config OR module readonly status.\r\n    private _updateHost(): void {\r\n        if (this._mayUpdateHost() || this.screenConfigNativeElement) {\r\n            if (!this.screenConfigNativeElement) {\r\n                this.hostComponent.objectConfigName = this.screenConfigurationObject;\r\n            }\r\n            const myCfgObj: ObjectConfiguration = this._configService.getObjectConfigurationFor(this.screenConfigurationObject);\r\n            if (myCfgObj) {\r\n                this._setHostVisible(myCfgObj.immediatelyVisible());\r\n                // if (this.hostComponent instanceof GridColumnComponent) {\r\n                //   this.hostComponent.rights = myCfgObj.rights;\r\n                // }\r\n                if (!this.screenConfigNativeElement) {\r\n                    this.hostComponent.required = myCfgObj.isRequired();\r\n                    this.hostComponent.readonly = this.hostComponent.forceReadonly || this._moduleInReadonlyMode() || myCfgObj.isReadonly();\r\n                    this.hostComponent.decimals = myCfgObj.scale;\r\n                    this.hostComponent.maxLength = myCfgObj.maxLength;\r\n                }\r\n            } else {\r\n                this._setHostVisible(false);\r\n                if (!this.screenConfigNativeElement) {\r\n                    this.hostComponent.readonly = this._moduleInReadonlyMode();\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Spawn error message tooltip onto our host comp, if any error was meant for the host (found by screenConfigurationObject);\r\n     * @param errorValidation A top-level full validation result, either from the backend or from some client-side validation error.\r\n     */\r\n    private _setErrorRedBackgroundAfterScrCfgValidate(errorValidation: ValidationResult): void {\r\n        if (this.hostComponent && errorValidation) {\r\n            const errorMessages: ValidationMessage[] = errorValidation.getAllErrorMessagesOfMyValidationFields();\r\n            for (let i: number = 0, len: number = errorMessages.length; i < len; i++) {\r\n                const errorMsg: ValidationMessage = errorMessages[i];\r\n                const configName: string = this.dataName ? this.dataName : this.screenConfigurationObject;\r\n                if (errorMsg.fieldId === configName && this._element /*&& this._properHost(errorMsg.boId)*/) {\r\n                    this.hostComponent.redErrorBackground = true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    private _moduleInReadonlyMode(): boolean {\r\n        return !this.noModuleService ? (this._moduleService ? this._moduleService.readonly : false) : false;\r\n    }\r\n\r\n    private _mayUpdateHost(): boolean {\r\n        return !!this.hostComponent && !this._isTurnedOff && !!this.screenConfigurationObject;\r\n    }\r\n\r\n    private _setHostVisible(visible: boolean): void {\r\n        if (!this.screenConfigNativeElement) {\r\n            this.hostComponent.hidden = !visible;\r\n        } else {\r\n            if (this._element && this._element.nativeElement) {\r\n                if (!visible) {\r\n                    this._renderer.addClass(this._element.nativeElement, 'hidden');\r\n                } else {\r\n                    this._renderer.removeClass(this._element.nativeElement, 'hidden');\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/directives/screen-configuration/screen-configuration.module.js

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { ScreenConfigurationDirective } from './screen-configuration.directive';
+import { CommonModule } from '@angular/common';
+export class ScreenConfigurationModule {
+}
+ScreenConfigurationModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule
+                ],
+                declarations: [
+                    ScreenConfigurationDirective
+                ],
+                exports: [
+                    ScreenConfigurationDirective,
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyZWVuLWNvbmZpZ3VyYXRpb24ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9kaXJlY3RpdmVzL3NjcmVlbi1jb25maWd1cmF0aW9uL3NjcmVlbi1jb25maWd1cmF0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyw0QkFBNEIsRUFBQyxNQUFNLGtDQUFrQyxDQUFDO0FBQzlFLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQWE3QyxNQUFNLE9BQU8seUJBQXlCOzs7WUFYckMsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO2lCQUNiO2dCQUNELFlBQVksRUFBRTtvQkFDWiw0QkFBNEI7aUJBQzdCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCw0QkFBNEI7aUJBQzdCO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7U2NyZWVuQ29uZmlndXJhdGlvbkRpcmVjdGl2ZX0gZnJvbSAnLi9zY3JlZW4tY29uZmlndXJhdGlvbi5kaXJlY3RpdmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGVcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgU2NyZWVuQ29uZmlndXJhdGlvbkRpcmVjdGl2ZVxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgU2NyZWVuQ29uZmlndXJhdGlvbkRpcmVjdGl2ZSxcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBTY3JlZW5Db25maWd1cmF0aW9uTW9kdWxlIHsgfVxuIl19

package/esm2015/lib/directives/stopclick/stop-click.directive.js

@@ -0,0 +1,38 @@
+import { Directive, ElementRef, Input, NgZone } from "@angular/core";
+import { EventUtils } from "../../core/utils/event-utils";
+export class StopClickDirective {
+    constructor(_elementRef, _ngZone) {
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._killEventHandler = (event) => {
+            if (this.stopClick) {
+                EventUtils.KillEvent(event);
+            }
+        };
+    }
+    ngOnInit() {
+        this._ngZone.runOutsideAngular(() => {
+            this._elementRef.nativeElement.addEventListener('click', this._killEventHandler);
+            this._elementRef.nativeElement.addEventListener('dblclick', this._killEventHandler);
+            this._elementRef.nativeElement.addEventListener('mousedown', this._killEventHandler);
+        });
+    }
+    ngOnDestroy() {
+        this._elementRef.nativeElement.removeEventListener('click', this._killEventHandler);
+        this._elementRef.nativeElement.removeEventListener('dblclick', this._killEventHandler);
+        this._elementRef.nativeElement.removeEventListener('mousedown', this._killEventHandler);
+    }
+}
+StopClickDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[stopClick]'
+            },] }
+];
+StopClickDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone }
+];
+StopClickDirective.propDecorators = {
+    stopClick: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/stopclick/stop-click.module.js

@@ -0,0 +1,15 @@
+import { NgModule } from "@angular/core";
+import { StopClickDirective } from "./stop-click.directive";
+export class StopClickModule {
+}
+StopClickModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    StopClickDirective
+                ],
+                exports: [
+                    StopClickDirective
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcC1jbGljay5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2RpcmVjdGl2ZXMvc3RvcGNsaWNrL3N0b3AtY2xpY2subW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFdkMsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFVMUQsTUFBTSxPQUFPLGVBQWU7OztZQVIzQixRQUFRLFNBQUM7Z0JBQ04sWUFBWSxFQUFFO29CQUNWLGtCQUFrQjtpQkFDckI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNMLGtCQUFrQjtpQkFDckI7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG5pbXBvcnQge1N0b3BDbGlja0RpcmVjdGl2ZX0gZnJvbSBcIi4vc3RvcC1jbGljay5kaXJlY3RpdmVcIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBkZWNsYXJhdGlvbnM6IFtcclxuICAgICAgICBTdG9wQ2xpY2tEaXJlY3RpdmVcclxuICAgIF0sXHJcbiAgICBleHBvcnRzOiBbXHJcbiAgICAgICAgU3RvcENsaWNrRGlyZWN0aXZlXHJcbiAgICBdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTdG9wQ2xpY2tNb2R1bGUge1xyXG59Il19

package/esm2015/lib/directives/template-wrapper/template-wrapper.directive.js

@@ -0,0 +1,68 @@
+import { Directive, Input, ViewContainerRef } from '@angular/core';
+export class TemplateWrapperDirective {
+    constructor(viewContainer) {
+        this.viewContainer = viewContainer;
+        this.templateWrapper = null;
+        this.templateWrapperContext = null;
+    }
+    ngOnChanges(changes) {
+        const recreateView = this._shouldRecreateView(changes);
+        if (recreateView) {
+            if (this._viewRef) {
+                this.viewContainer.remove(this.viewContainer.indexOf(this._viewRef));
+            }
+            if (this.templateWrapper) {
+                this._viewRef = this.viewContainer.createEmbeddedView(this.templateWrapper, this.templateWrapperContext);
+            }
+        }
+        else {
+            if (this._viewRef && this.templateWrapperContext) {
+                this._updateExistingContext(this.templateWrapperContext);
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this._viewRef) {
+            this.viewContainer.remove(this.viewContainer.indexOf(this._viewRef));
+            this._viewRef = undefined;
+        }
+        this.templateWrapper = undefined;
+    }
+    _shouldRecreateView(changes) {
+        const ctxChange = changes['templateWrapperContext'];
+        return !!changes['templateWrapper'] || (ctxChange && this._hasContextShapeChanged(ctxChange));
+    }
+    _hasContextShapeChanged(ctxChange) {
+        const prevCtxKeys = Object.keys(ctxChange.previousValue || {});
+        const currCtxKeys = Object.keys(ctxChange.currentValue || {});
+        if (prevCtxKeys.length === currCtxKeys.length) {
+            for (const propName of currCtxKeys) {
+                if (prevCtxKeys.indexOf(propName) === -1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    _updateExistingContext(ctx) {
+        for (const propName of Object.keys(ctx)) {
+            this._viewRef.context[propName] = this.templateWrapperContext[propName];
+        }
+    }
+}
+TemplateWrapperDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[templateWrapper]'
+            },] }
+];
+TemplateWrapperDirective.ctorParameters = () => [
+    { type: ViewContainerRef }
+];
+TemplateWrapperDirective.propDecorators = {
+    templateWrapper: [{ type: Input }],
+    templateWrapperContext: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/template-wrapper/template-wrapper.module.js

@@ -0,0 +1,15 @@
+import { NgModule } from "@angular/core";
+import { TemplateWrapperDirective } from "./template-wrapper.directive";
+export class TemplateWrapperModule {
+}
+TemplateWrapperModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    TemplateWrapperDirective
+                ],
+                exports: [
+                    TemplateWrapperDirective
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUtd3JhcHBlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2RpcmVjdGl2ZXMvdGVtcGxhdGUtd3JhcHBlci90ZW1wbGF0ZS13cmFwcGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyx3QkFBd0IsRUFBQyxNQUFNLDhCQUE4QixDQUFDO0FBVXRFLE1BQU0sT0FBTyxxQkFBcUI7OztZQVJqQyxRQUFRLFNBQUM7Z0JBQ04sWUFBWSxFQUFFO29CQUNWLHdCQUF3QjtpQkFDM0I7Z0JBQ0QsT0FBTyxFQUFFO29CQUNMLHdCQUF3QjtpQkFDM0I7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7VGVtcGxhdGVXcmFwcGVyRGlyZWN0aXZlfSBmcm9tIFwiLi90ZW1wbGF0ZS13cmFwcGVyLmRpcmVjdGl2ZVwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICAgIGRlY2xhcmF0aW9uczogW1xyXG4gICAgICAgIFRlbXBsYXRlV3JhcHBlckRpcmVjdGl2ZVxyXG4gICAgXSxcclxuICAgIGV4cG9ydHM6IFtcclxuICAgICAgICBUZW1wbGF0ZVdyYXBwZXJEaXJlY3RpdmVcclxuICAgIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIFRlbXBsYXRlV3JhcHBlck1vZHVsZSB7XHJcbn1cclxuIl19