@theseam/ui-common 0.2.9

package/esm2015/shared/directives/ng-select-extra.directive.js

@@ -0,0 +1,177 @@
+import { Directive, ElementRef, EventEmitter, HostBinding, HostListener, NgZone, Optional, Self } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { NgSelectComponent } from '@ng-select/ng-select';
+import { ResizeSensor } from 'css-element-queries';
+export class NgSelectExtraDirective {
+    constructor(elementRef, _ngZone, ngSelect, ngControl) {
+        this.elementRef = elementRef;
+        this._ngZone = _ngZone;
+        this.ngSelect = ngSelect;
+        this.ngControl = ngControl;
+        this._ngUnsubscribe = new Subject();
+        this._markedItem = null;
+        this._checkMarked = false;
+        this._keyPressWorkaroundSub = null;
+        this._resizedEvent = new EventEmitter();
+        this._onScroll = (event) => {
+            if (this.ngSelect && this.ngSelect.isOpen) {
+                const isScrollingInScrollHost = event.target.className.indexOf('ng-dropdown-panel-items') !== -1;
+                const isInSensor = event.target.className.indexOf('resize-sensor-shrink') !== -1 ||
+                    event.target.className.indexOf('os-resize-observer-host') !== -1;
+                if (isScrollingInScrollHost || isInSensor) {
+                    return;
+                }
+                this.ngSelect.close();
+            }
+        };
+    }
+    /**
+     * Set the tab index to `-1` to allow the root element of the ng-select
+     * component to receive `focus` event from javascript, but not get focused by
+     * keyboard navigation.
+     */
+    get _tabIndex() { return this.ngSelect.disabled ? undefined : -1; }
+    /**
+     * Listening for focus event on root of component to allow javascript
+     * `focus()` function to trigger the components focus.
+     */
+    onFocus($event) {
+        const target = $event.target;
+        if (target === this.elementRef.nativeElement && !this.ngSelect.disabled) {
+            this.ngSelect.focus();
+        }
+        // ng-select has an input `labelForId` that sets the autocomplete attribute
+        // in ngOnInit. I am not positive that it is wrong by doing that, but this
+        // hack makes it set the attributes again on focus, because that gives the
+        // result I was expecting, since we don't manually set the `labelForId`
+        // input.
+        const _ngSelect = this.ngSelect;
+        _ngSelect._setInputAttributes();
+    }
+    get _isInvalid() {
+        return this.ngControl ? this.ngControl.invalid && (this.ngControl.dirty || this.ngControl.touched) : false;
+    }
+    get _isEmptyStringValue() {
+        return this.ngControl ? this.ngControl.value === '' ? true : false : false;
+    }
+    ngOnInit() {
+        this.ngSelect.focusEvent
+            .subscribe(v => this._enableKeyPressWorkaround());
+        this.ngSelect.blurEvent
+            .subscribe(v => this._disableKeyPressWorkaround());
+        window.addEventListener('scroll', this._onScroll, true);
+        // When the input is allowed to change its height the position doesn't update itself.
+        // this._resizedEvent.pipe(
+        //   auditTime(30)
+        // ).subscribe(event => {
+        //   if (this.elementRef && this.elementRef.nativeElement) {
+        //     if (this.elementRef.nativeElement.classList.contains('ng-select-value-grow-h')) {
+        //       if (this.ngSelect.isOpen && this.ngSelect.dropdownPanel) {
+        //         this.ngSelect.dropdownPanel.updateDropdownPosition()
+        //       }
+        //     } else {
+        //       this.elementRef.nativeElement.classList.remove('ng-select-value-grow-h')
+        //     }
+        //   }
+        // })
+        // this._patch_ngSelect_open()
+    }
+    ngOnDestroy() {
+        var _a;
+        (_a = this._resizeSensor) === null || _a === void 0 ? void 0 : _a.detach();
+        window.removeEventListener('scroll', this._onScroll, true);
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterViewChecked() {
+        if (this.ngSelect.dropdownPanel) {
+            if (this._checkMarked) {
+                if (this.ngSelect.dropdownPanel && this._markedItem !== null) {
+                    if (this._markedItem.index !== this.ngSelect.dropdownPanel.markedItem.index) {
+                        this.ngSelect.dropdownPanel.scrollTo(this.ngSelect.dropdownPanel.markedItem);
+                    }
+                }
+            }
+        }
+        this._checkMarked = false;
+        this._resizeSensor = new ResizeSensor(this.elementRef.nativeElement, (event) => {
+            this._resizedEvent.emit({ element: this.elementRef.nativeElement, size: event });
+        });
+    }
+    /**
+     * Temp fix for: https://github.com/ng-select/ng-select/issues/1122
+     */
+    // private _patch_ngSelect_open() {
+    //   const original = this.ngSelect.open
+    //   const _self = this
+    //   this.ngSelect.open = function() {
+    //     original.apply(this, arguments)
+    //     _self._patch_ngSelectDropdownPanel_updateDropdownPosition()
+    //   }
+    // }
+    /** Should ONLY be called by `_patch_ngSelect_open`. */
+    // private _patch_ngSelectDropdownPanel_updateDropdownPosition() {
+    //   if (!this.ngSelect.dropdownPanel) { return }
+    //   const drop: any = this.ngSelect.dropdownPanel
+    //   // Only needed once, to update the position before the timeout in
+    //   // `updateDropdownPosition()`. So, using this variable to check if I already called
+    //   // `_updateAppendedDropdownPosition()`.
+    //   if (!drop.__libPatched) {
+    //     drop.__libPatched = 'patched'
+    //     const original = drop.updateDropdownPosition
+    //     const _self = this
+    //     drop.updateDropdownPosition = function() {
+    //       original.apply(this, arguments)
+    //       if (!!_self.ngSelect.appendTo) {
+    //         drop._updateAppendedDropdownPosition()
+    //       }
+    //     }
+    //   }
+    // }
+    _enableKeyPressWorkaround() {
+        if (this._keyPressWorkaroundSub) {
+            return;
+        }
+        const _ngSelect = this.ngSelect;
+        this._keyPressWorkaroundSub = _ngSelect._keyPress$
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .pipe(filter(() => !this.ngSelect.searchable))
+            .subscribe(() => {
+            this._ngZone.runOutsideAngular(() => {
+                window.requestAnimationFrame(() => {
+                    if (this.ngSelect.dropdownPanel) {
+                        this._markedItem = this.ngSelect.dropdownPanel.markedItem;
+                    }
+                    this._checkMarked = true;
+                });
+            });
+        });
+    }
+    _disableKeyPressWorkaround() {
+        if (this._keyPressWorkaroundSub) {
+            this._keyPressWorkaroundSub.unsubscribe();
+            this._keyPressWorkaroundSub = null;
+        }
+    }
+}
+NgSelectExtraDirective.decorators = [
+    { type: Directive, args: [{
+                // tslint:disable-next-line:directive-selector
+                selector: 'ng-select'
+            },] }
+];
+NgSelectExtraDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone },
+    { type: NgSelectComponent },
+    { type: NgControl, decorators: [{ type: Optional }, { type: Self }] }
+];
+NgSelectExtraDirective.propDecorators = {
+    _tabIndex: [{ type: HostBinding, args: ['attr.tabIndex',] }],
+    onFocus: [{ type: HostListener, args: ['focus', ['$event'],] }],
+    _isInvalid: [{ type: HostBinding, args: ['class.is-invalid',] }],
+    _isEmptyStringValue: [{ type: HostBinding, args: ['class.ng-empty-string-value',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-select-extra.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/shared/directives/ng-select-extra.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewChecked, Directive, ElementRef, EventEmitter, HostBinding,\n  HostListener, NgZone, OnDestroy, OnInit, Optional, Self } from '@angular/core'\nimport { NgControl } from '@angular/forms'\nimport { Subject, Subscription } from 'rxjs'\nimport { filter, takeUntil } from 'rxjs/operators'\n\nimport { NgOption, NgSelectComponent } from '@ng-select/ng-select'\nimport { ResizeSensor } from 'css-element-queries'\n\nimport { IElementResizedEvent } from './elem-resized.directive'\n\n@Directive({\n  // tslint:disable-next-line:directive-selector\n  selector: 'ng-select'\n})\nexport class NgSelectExtraDirective implements OnInit, AfterViewChecked, OnDestroy {\n\n  private readonly _ngUnsubscribe = new Subject()\n\n  private _markedItem: NgOption | null = null\n  private _checkMarked = false\n  private _keyPressWorkaroundSub: Subscription | null = null\n\n  private _resizedEvent = new EventEmitter<IElementResizedEvent>()\n  private _resizeSensor?: ResizeSensor\n\n  /**\n   * Set the tab index to `-1` to allow the root element of the ng-select\n   * component to receive `focus` event from javascript, but not get focused by\n   * keyboard navigation.\n   */\n  @HostBinding('attr.tabIndex')\n  get _tabIndex() { return this.ngSelect.disabled ? undefined : -1 }\n\n  /**\n   * Listening for focus event on root of component to allow javascript\n   * `focus()` function to trigger the components focus.\n   */\n  @HostListener('focus', ['$event']) onFocus($event: FocusEvent) {\n    const target = $event.target as HTMLElement\n    if (target === this.elementRef.nativeElement && !this.ngSelect.disabled) {\n      this.ngSelect.focus()\n    }\n\n    // ng-select has an input `labelForId` that sets the autocomplete attribute\n    // in ngOnInit. I am not positive that it is wrong by doing that, but this\n    // hack makes it set the attributes again on focus, because that gives the\n    // result I was expecting, since we don't manually set the `labelForId`\n    // input.\n    const _ngSelect = this.ngSelect as any\n    _ngSelect._setInputAttributes()\n  }\n\n  @HostBinding('class.is-invalid') get _isInvalid() {\n    return this.ngControl ? this.ngControl.invalid && (this.ngControl.dirty || this.ngControl.touched) : false\n  }\n\n  @HostBinding('class.ng-empty-string-value') get _isEmptyStringValue() {\n    return this.ngControl ? this.ngControl.value === '' ? true : false : false\n  }\n\n  constructor(\n    private readonly elementRef: ElementRef,\n    private readonly _ngZone: NgZone,\n    private readonly ngSelect: NgSelectComponent,\n    @Optional() @Self() public readonly ngControl: NgControl\n  ) { }\n\n  ngOnInit() {\n    this.ngSelect.focusEvent\n      .subscribe(v => this._enableKeyPressWorkaround())\n\n    this.ngSelect.blurEvent\n      .subscribe(v => this._disableKeyPressWorkaround())\n\n    window.addEventListener('scroll', this._onScroll, true)\n\n    // When the input is allowed to change its height the position doesn't update itself.\n    // this._resizedEvent.pipe(\n    //   auditTime(30)\n    // ).subscribe(event => {\n    //   if (this.elementRef && this.elementRef.nativeElement) {\n    //     if (this.elementRef.nativeElement.classList.contains('ng-select-value-grow-h')) {\n    //       if (this.ngSelect.isOpen && this.ngSelect.dropdownPanel) {\n    //         this.ngSelect.dropdownPanel.updateDropdownPosition()\n    //       }\n    //     } else {\n    //       this.elementRef.nativeElement.classList.remove('ng-select-value-grow-h')\n    //     }\n    //   }\n    // })\n\n    // this._patch_ngSelect_open()\n  }\n\n  ngOnDestroy() {\n    this._resizeSensor?.detach()\n\n    window.removeEventListener('scroll', this._onScroll, true)\n\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  ngAfterViewChecked() {\n    if (this.ngSelect.dropdownPanel) {\n      if (this._checkMarked) {\n        if (this.ngSelect.dropdownPanel && this._markedItem !== null) {\n          if (this._markedItem.index !== this.ngSelect.dropdownPanel.markedItem.index) {\n            this.ngSelect.dropdownPanel.scrollTo(this.ngSelect.dropdownPanel.markedItem)\n          }\n        }\n      }\n    }\n    this._checkMarked = false\n\n    this._resizeSensor = new ResizeSensor(this.elementRef.nativeElement, (event) => {\n      this._resizedEvent.emit({ element: this.elementRef.nativeElement, size: event })\n    })\n  }\n\n  private _onScroll = (event: any) => {\n    if (this.ngSelect && this.ngSelect.isOpen) {\n      const isScrollingInScrollHost = (event.target.className as string).indexOf('ng-dropdown-panel-items') !== -1\n      const isInSensor = (event.target.className as string).indexOf('resize-sensor-shrink') !== -1 ||\n        (event.target.className as string).indexOf('os-resize-observer-host') !== -1\n      if (isScrollingInScrollHost || isInSensor) { return }\n      this.ngSelect.close()\n    }\n}\n\n  /**\n   * Temp fix for: https://github.com/ng-select/ng-select/issues/1122\n   */\n  // private _patch_ngSelect_open() {\n  //   const original = this.ngSelect.open\n  //   const _self = this\n  //   this.ngSelect.open = function() {\n  //     original.apply(this, arguments)\n  //     _self._patch_ngSelectDropdownPanel_updateDropdownPosition()\n  //   }\n  // }\n\n  /** Should ONLY be called by `_patch_ngSelect_open`. */\n  // private _patch_ngSelectDropdownPanel_updateDropdownPosition() {\n  //   if (!this.ngSelect.dropdownPanel) { return }\n  //   const drop: any = this.ngSelect.dropdownPanel\n  //   // Only needed once, to update the position before the timeout in\n  //   // `updateDropdownPosition()`. So, using this variable to check if I already called\n  //   // `_updateAppendedDropdownPosition()`.\n  //   if (!drop.__libPatched) {\n  //     drop.__libPatched = 'patched'\n  //     const original = drop.updateDropdownPosition\n  //     const _self = this\n  //     drop.updateDropdownPosition = function() {\n  //       original.apply(this, arguments)\n  //       if (!!_self.ngSelect.appendTo) {\n  //         drop._updateAppendedDropdownPosition()\n  //       }\n  //     }\n  //   }\n  // }\n\n  private _enableKeyPressWorkaround() {\n    if (this._keyPressWorkaroundSub) { return }\n    const _ngSelect = <any>this.ngSelect\n\n    this._keyPressWorkaroundSub = _ngSelect._keyPress$\n      .pipe(takeUntil(this._ngUnsubscribe))\n      .pipe(filter(() => !this.ngSelect.searchable))\n      .subscribe(() => {\n        this._ngZone.runOutsideAngular(() => {\n          window.requestAnimationFrame(() => {\n            if (this.ngSelect.dropdownPanel) {\n              this._markedItem = this.ngSelect.dropdownPanel.markedItem\n            }\n            this._checkMarked = true\n          })\n        })\n      })\n  }\n\n  private _disableKeyPressWorkaround() {\n    if (this._keyPressWorkaroundSub) {\n      this._keyPressWorkaroundSub.unsubscribe()\n      this._keyPressWorkaroundSub = null\n    }\n  }\n\n}\n"]}

package/esm2015/shared/directives/ngx-quill-extra.directive.js

@@ -0,0 +1,60 @@
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Directive, ElementRef, HostBinding, Input } from '@angular/core';
+import { fromEvent, Subject } from 'rxjs';
+import { filter, takeUntil, tap } from 'rxjs/operators';
+import { QuillEditorComponent } from 'ngx-quill';
+export class NgxQuillExtraDirective {
+    constructor(_elementRef, _quillEditor) {
+        this._elementRef = _elementRef;
+        this._quillEditor = _quillEditor;
+        this._ngUnsubscribe = new Subject();
+        this._tabIndex = -1;
+    }
+    /**
+     * Set the tab index to `-1` to allow the root element of the
+     * component to receive `focus` event from javascript, but not get focused by
+     * keyboard navigation.
+     */
+    set tabIndex(value) { this._tabIndex = coerceNumberProperty(value); }
+    get tabIndex() { return this._tabIndex; }
+    get _attrTabIndex() { return this._quillEditor.disabled ? -1 : (this.tabIndex || 0); }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterViewInit() {
+        const parent = this._getParentElementForLabelFocusIssue();
+        if (parent) {
+            // NOTE: This is a hack to avoid an issue letting a label with "for"
+            // attribute focus the control.
+            fromEvent(parent, 'click').pipe(takeUntil(this._ngUnsubscribe), filter(e => { var _a; return ((_a = e.target) === null || _a === void 0 ? void 0 : _a.getAttribute('for')) === this._elementRef.nativeElement.id; }), tap(() => this._quillEditor.quillEditor.focus())).subscribe();
+        }
+    }
+    _getParentElementForLabelFocusIssue() {
+        const findElem = (elem) => {
+            if (elem.nodeName.toLowerCase() === 'seam-form-field') {
+                return elem;
+            }
+            if (elem.parentElement) {
+                return findElem(elem.parentElement);
+            }
+            return elem;
+        };
+        return findElem(this._elementRef.nativeElement);
+    }
+}
+NgxQuillExtraDirective.decorators = [
+    { type: Directive, args: [{
+                // tslint:disable-next-line:directive-selector
+                selector: 'quill-editor'
+            },] }
+];
+NgxQuillExtraDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: QuillEditorComponent }
+];
+NgxQuillExtraDirective.propDecorators = {
+    tabIndex: [{ type: Input }],
+    _attrTabIndex: [{ type: HostBinding, args: ['attr.tabindex',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/shared/pipes/index.js

@@ -0,0 +1,3 @@
+export * from './mask-chars.pipe';
+export * from './truncate.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vc2hhcmVkL3BpcGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsY0FBYyxpQkFBaUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWFzay1jaGFycy5waXBlJ1xuZXhwb3J0ICogZnJvbSAnLi90cnVuY2F0ZS5waXBlJ1xuIl19

package/esm2015/shared/pipes/mask-chars.pipe.js

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import { padEnd, padStart } from '@theseam/ui-common/utils';
+export class MaskCharsPipe {
+    transform(value, replacementChar = '*', ignoreCount = 0, ignoreFrom = 'right') {
+        if (ignoreFrom === 'right') {
+            const s = value || '';
+            return padStart(s.substring(s.length - ignoreCount, s.length), s.length, replacementChar);
+        }
+        else if (ignoreFrom === 'left') {
+            const s = value || '';
+            return padEnd(s.substring(0, ignoreCount), s.length, replacementChar);
+        }
+        return value;
+    }
+}
+MaskCharsPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'maskChars'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFzay1jaGFycy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL3NoYXJlZC9waXBlcy9tYXNrLWNoYXJzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUE7QUFFbkQsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQTtBQUszRCxNQUFNLE9BQU8sYUFBYTtJQUV4QixTQUFTLENBQUMsS0FBYSxFQUFFLGtCQUEwQixHQUFHLEVBQUUsY0FBc0IsQ0FBQyxFQUFFLGFBQStCLE9BQU87UUFDckgsSUFBSSxVQUFVLEtBQUssT0FBTyxFQUFFO1lBQzFCLE1BQU0sQ0FBQyxHQUFHLEtBQUssSUFBSSxFQUFFLENBQUE7WUFDckIsT0FBTyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsTUFBTSxHQUFHLFdBQVcsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxlQUFlLENBQUMsQ0FBQTtTQUMxRjthQUFNLElBQUksVUFBVSxLQUFLLE1BQU0sRUFBRTtZQUNoQyxNQUFNLENBQUMsR0FBRyxLQUFLLElBQUksRUFBRSxDQUFBO1lBQ3JCLE9BQU8sTUFBTSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLFdBQVcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsZUFBZSxDQUFDLENBQUE7U0FDdEU7UUFFRCxPQUFPLEtBQUssQ0FBQTtJQUNkLENBQUM7OztZQWZGLElBQUksU0FBQztnQkFDSixJQUFJLEVBQUUsV0FBVzthQUNsQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBwYWRFbmQsIHBhZFN0YXJ0IH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL3V0aWxzJ1xuXG5AUGlwZSh7XG4gIG5hbWU6ICdtYXNrQ2hhcnMnXG59KVxuZXhwb3J0IGNsYXNzIE1hc2tDaGFyc1BpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICB0cmFuc2Zvcm0odmFsdWU6IHN0cmluZywgcmVwbGFjZW1lbnRDaGFyOiBzdHJpbmcgPSAnKicsIGlnbm9yZUNvdW50OiBudW1iZXIgPSAwLCBpZ25vcmVGcm9tOiAnbGVmdCcgfCAncmlnaHQnID0gJ3JpZ2h0Jyk6IHN0cmluZyB7XG4gICAgaWYgKGlnbm9yZUZyb20gPT09ICdyaWdodCcpIHtcbiAgICAgIGNvbnN0IHMgPSB2YWx1ZSB8fCAnJ1xuICAgICAgcmV0dXJuIHBhZFN0YXJ0KHMuc3Vic3RyaW5nKHMubGVuZ3RoIC0gaWdub3JlQ291bnQsIHMubGVuZ3RoKSwgcy5sZW5ndGgsIHJlcGxhY2VtZW50Q2hhcilcbiAgICB9IGVsc2UgaWYgKGlnbm9yZUZyb20gPT09ICdsZWZ0Jykge1xuICAgICAgY29uc3QgcyA9IHZhbHVlIHx8ICcnXG4gICAgICByZXR1cm4gcGFkRW5kKHMuc3Vic3RyaW5nKDAsIGlnbm9yZUNvdW50KSwgcy5sZW5ndGgsIHJlcGxhY2VtZW50Q2hhcilcbiAgICB9XG5cbiAgICByZXR1cm4gdmFsdWVcbiAgfVxuXG59XG4iXX0=

package/esm2015/shared/pipes/truncate.pipe.js

@@ -0,0 +1,19 @@
+import { Pipe } from '@angular/core';
+export class TruncatePipe {
+    transform(value, length = 30, appendEllipsis = true) {
+        let val = value;
+        if (value && typeof value === 'string' && value.length > length) {
+            val = value.substr(0, length);
+            if (appendEllipsis) {
+                val += '...';
+            }
+        }
+        return val;
+    }
+}
+TruncatePipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'truncate'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1bmNhdGUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zaGFyZWQvcGlwZXMvdHJ1bmNhdGUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQTtBQUtuRCxNQUFNLE9BQU8sWUFBWTtJQUV2QixTQUFTLENBQUMsS0FBYSxFQUFFLFNBQWlCLEVBQUUsRUFBRSxpQkFBMEIsSUFBSTtRQUMxRSxJQUFJLEdBQUcsR0FBRyxLQUFLLENBQUE7UUFFZixJQUFJLEtBQUssSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLE1BQU0sR0FBRyxNQUFNLEVBQUU7WUFDL0QsR0FBRyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFBO1lBQzdCLElBQUksY0FBYyxFQUFFO2dCQUNsQixHQUFHLElBQUksS0FBSyxDQUFBO2FBQ2I7U0FDRjtRQUVELE9BQU8sR0FBRyxDQUFBO0lBQ1osQ0FBQzs7O1lBaEJGLElBQUksU0FBQztnQkFDSixJQUFJLEVBQUUsVUFBVTthQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5AUGlwZSh7XG4gIG5hbWU6ICd0cnVuY2F0ZSdcbn0pXG5leHBvcnQgY2xhc3MgVHJ1bmNhdGVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgdHJhbnNmb3JtKHZhbHVlOiBzdHJpbmcsIGxlbmd0aDogbnVtYmVyID0gMzAsIGFwcGVuZEVsbGlwc2lzOiBib29sZWFuID0gdHJ1ZSk6IHN0cmluZyB7XG4gICAgbGV0IHZhbCA9IHZhbHVlXG5cbiAgICBpZiAodmFsdWUgJiYgdHlwZW9mIHZhbHVlID09PSAnc3RyaW5nJyAmJiB2YWx1ZS5sZW5ndGggPiBsZW5ndGgpIHtcbiAgICAgIHZhbCA9IHZhbHVlLnN1YnN0cigwLCBsZW5ndGgpXG4gICAgICBpZiAoYXBwZW5kRWxsaXBzaXMpIHtcbiAgICAgICAgdmFsICs9ICcuLi4nXG4gICAgICB9XG4gICAgfVxuXG4gICAgcmV0dXJuIHZhbFxuICB9XG5cbn1cbiJdfQ==

package/esm2015/shared/public-api.js

@@ -0,0 +1,5 @@
+export * from './components/index';
+export * from './directives/index';
+export * from './pipes/index';
+export * from './shared.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zaGFyZWQvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUE7QUFDbEMsY0FBYyxlQUFlLENBQUE7QUFFN0IsY0FBYyxpQkFBaUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vcGlwZXMvaW5kZXgnXG5cbmV4cG9ydCAqIGZyb20gJy4vc2hhcmVkLm1vZHVsZSdcbiJdfQ==

package/esm2015/shared/shared.module.js

@@ -0,0 +1,58 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
+import { TheSeamLoadingModule } from '@theseam/ui-common/loading';
+import { TheSeamModalModule } from '@theseam/ui-common/modal';
+import { TheSeamScrollbarModule } from '@theseam/ui-common/scrollbar';
+import { AutoFocusDirective } from './directives/auto-focus.directive';
+import { ClickOutsideDirective } from './directives/click-outside.directive';
+import { DisableControlDirective } from './directives/disable-control.directive';
+import { ElemResizedDirective } from './directives/elem-resized.directive';
+import { HoverClassToggleDirective } from './directives/hover-class-toggle.directive';
+import { HoverClassDirective } from './directives/hover-class.directive';
+import { NgSelectExtraDirective } from './directives/ng-select-extra.directive';
+import { NgxQuillExtraDirective } from './directives/ngx-quill-extra.directive';
+import { MaskCharsPipe } from './pipes/mask-chars.pipe';
+import { TruncatePipe } from './pipes/truncate.pipe';
+import { PasswordInputRevealComponent } from './components/password-input-reveal/password-input-reveal.component';
+export class TheSeamSharedModule {
+}
+TheSeamSharedModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    FontAwesomeModule,
+                    TheSeamModalModule,
+                    TheSeamLoadingModule
+                ],
+                declarations: [
+                    AutoFocusDirective,
+                    ElemResizedDirective,
+                    PasswordInputRevealComponent,
+                    NgSelectExtraDirective,
+                    HoverClassDirective,
+                    HoverClassToggleDirective,
+                    ClickOutsideDirective,
+                    DisableControlDirective,
+                    MaskCharsPipe,
+                    TruncatePipe,
+                    NgxQuillExtraDirective
+                ],
+                exports: [
+                    AutoFocusDirective,
+                    ElemResizedDirective,
+                    PasswordInputRevealComponent,
+                    NgSelectExtraDirective,
+                    HoverClassDirective,
+                    HoverClassToggleDirective,
+                    ClickOutsideDirective,
+                    DisableControlDirective,
+                    MaskCharsPipe,
+                    TruncatePipe,
+                    NgxQuillExtraDirective,
+                    // Exporting scrollbars here for backwards compatibility for now.
+                    TheSeamScrollbarModule
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/shared/theseam-ui-common-shared.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlc2VhbS11aS1jb21tb24tc2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL3NoYXJlZC90aGVzZWFtLXVpLWNvbW1vbi1zaGFyZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/storage/local-storage.service.js

@@ -0,0 +1,77 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, fromEvent } from 'rxjs';
+import { filter, map, tap } from 'rxjs/operators';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import { LocalStorageMemory } from './localstorage-memory';
+import * as i0 from "@angular/core";
+// NOTE: Temporary localStorage polyfill just to get the app running without localStorage for now.
+const localStorage = 'localStorage' in window && window.localStorage != null ? window.localStorage : new LocalStorageMemory();
+export class LocalStorageService {
+    constructor() {
+        this.subjects = {};
+        /** This is only here for testing/debugging. */
+        this._localStorage = localStorage;
+        fromEvent(window, 'storage').pipe(map(e => e.key), filter(notNullOrUndefined), tap(key => {
+            const subjectValue = this.get(key);
+            const storedValue = this._localStorage.getItem(key);
+            if (subjectValue !== storedValue) {
+                if (storedValue) {
+                    this.set(key, storedValue);
+                }
+                else {
+                    this.remove(key);
+                }
+            }
+        }))
+            .subscribe();
+    }
+    /**
+     * Observe a localStorage item.
+     *
+     * NOTE: Only emits changes if the item is changed with the set method of this
+     * class instance.
+     */
+    select(key, defaultValue = null) {
+        if (this.subjects.hasOwnProperty(key)) {
+            return this.subjects[key];
+        }
+        if (!this._localStorage.getItem(key) && defaultValue) {
+            this._localStorage.setItem(key, defaultValue);
+        }
+        const value = this._localStorage.getItem(key) || defaultValue;
+        return (this.subjects[key] = new BehaviorSubject(value));
+    }
+    /** Get a localStorage item. */
+    get(key, defaultValue = null) {
+        if (this.subjects.hasOwnProperty(key)) {
+            return this.subjects[key].value;
+        }
+        if (!this._localStorage.getItem(key) && defaultValue) {
+            this._localStorage.setItem(key, defaultValue);
+        }
+        const value = this._localStorage.getItem(key) || defaultValue;
+        return (this.subjects[key] = new BehaviorSubject(value)).value;
+    }
+    /** Set a localStorage item. */
+    set(key, value) {
+        this._localStorage.setItem(key, value);
+        if (this.subjects.hasOwnProperty(key)) {
+            this.subjects[key].next(value);
+        }
+    }
+    /** Remove a localStorage item. */
+    remove(key) {
+        this._localStorage.removeItem(key);
+        if (this.subjects.hasOwnProperty(key)) {
+            this.subjects[key].next(null);
+        }
+    }
+}
+LocalStorageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LocalStorageService_Factory() { return new LocalStorageService(); }, token: LocalStorageService, providedIn: "root" });
+LocalStorageService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+LocalStorageService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/storage/localstorage-memory.js

@@ -0,0 +1,64 @@
+export class LocalStorageMemory {
+    constructor() {
+        this._cache = {};
+        /**
+         * Number of stored items.
+         */
+        this.length = 0;
+    }
+    /**
+     * Removes all stored items and sets length to 0.
+     */
+    clear() {
+        this._cache = {};
+        this.length = 0;
+    }
+    /**
+     * Returns item for passed key, or null.
+     *
+     * @param key name of item to be returned.
+     */
+    getItem(key) {
+        if (key in this._cache) {
+            return this._cache[key];
+        }
+        return null;
+    }
+    /**
+     * Returns name of key at passed index.
+     *
+     * @param index position for key to be returned (starts at 0).
+     */
+    key(index) {
+        return Object.keys(this._cache)[index] || null;
+    }
+    /**
+     * Removes item for passed key.
+     *
+     * @param key name of item to be removed.
+     */
+    removeItem(key) {
+        if (this._cache.hasOwnProperty(key)) {
+            delete this._cache[key];
+            this.length--;
+        }
+    }
+    /**
+     * Sets item for key to passed value, as string.
+     *
+     * @param key name of item to be set.
+     * @param value value, will always be turned into a string.
+     */
+    setItem(key, value) {
+        if (typeof value === 'undefined') {
+            this.removeItem(key);
+        }
+        else {
+            if (!this._cache.hasOwnProperty(key)) {
+                this.length++;
+            }
+            this._cache[key] = '' + value;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxzdG9yYWdlLW1lbW9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zdG9yYWdlL2xvY2Fsc3RvcmFnZS1tZW1vcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsTUFBTSxPQUFPLGtCQUFrQjtJQUEvQjtRQUdVLFdBQU0sR0FBOEIsRUFBRSxDQUFBO1FBRTlDOztXQUVHO1FBQ0ksV0FBTSxHQUFXLENBQUMsQ0FBQTtJQThEM0IsQ0FBQztJQTVEQzs7T0FFRztJQUNJLEtBQUs7UUFDVixJQUFJLENBQUMsTUFBTSxHQUFHLEVBQUUsQ0FBQTtRQUNoQixJQUFJLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQTtJQUNqQixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLE9BQU8sQ0FBQyxHQUFXO1FBQ3hCLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDdEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1NBQ3hCO1FBRUQsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEdBQUcsQ0FBQyxLQUFhO1FBQ3RCLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksSUFBSSxDQUFBO0lBQ2hELENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksVUFBVSxDQUFDLEdBQVc7UUFDM0IsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsRUFBRTtZQUNuQyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDdkIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFBO1NBQ2Q7SUFDSCxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxPQUFPLENBQUMsR0FBVyxFQUFFLEtBQWE7UUFDdkMsSUFBSSxPQUFPLEtBQUssS0FBSyxXQUFXLEVBQUU7WUFDaEMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQTtTQUNyQjthQUFNO1lBQ0wsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxFQUFFO2dCQUNwQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUE7YUFDZDtZQUVELElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxHQUFHLEtBQUssQ0FBQTtTQUM5QjtJQUNILENBQUM7Q0FFRiIsInNvdXJjZXNDb250ZW50IjpbIlxuZXhwb3J0IGNsYXNzIExvY2FsU3RvcmFnZU1lbW9yeSBpbXBsZW1lbnRzIFN0b3JhZ2Uge1xuICBbbmFtZTogc3RyaW5nXTogYW55XG5cbiAgcHJpdmF0ZSBfY2FjaGU6IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH0gPSB7fVxuXG4gIC8qKlxuICAgKiBOdW1iZXIgb2Ygc3RvcmVkIGl0ZW1zLlxuICAgKi9cbiAgcHVibGljIGxlbmd0aDogbnVtYmVyID0gMFxuXG4gIC8qKlxuICAgKiBSZW1vdmVzIGFsbCBzdG9yZWQgaXRlbXMgYW5kIHNldHMgbGVuZ3RoIHRvIDAuXG4gICAqL1xuICBwdWJsaWMgY2xlYXIoKTogdm9pZCB7XG4gICAgdGhpcy5fY2FjaGUgPSB7fVxuICAgIHRoaXMubGVuZ3RoID0gMFxuICB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgaXRlbSBmb3IgcGFzc2VkIGtleSwgb3IgbnVsbC5cbiAgICpcbiAgICogQHBhcmFtIGtleSBuYW1lIG9mIGl0ZW0gdG8gYmUgcmV0dXJuZWQuXG4gICAqL1xuICBwdWJsaWMgZ2V0SXRlbShrZXk6IHN0cmluZyk6IHN0cmluZyB8IG51bGwge1xuICAgIGlmIChrZXkgaW4gdGhpcy5fY2FjaGUpIHtcbiAgICAgIHJldHVybiB0aGlzLl9jYWNoZVtrZXldXG4gICAgfVxuXG4gICAgcmV0dXJuIG51bGxcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIG5hbWUgb2Yga2V5IGF0IHBhc3NlZCBpbmRleC5cbiAgICpcbiAgICogQHBhcmFtIGluZGV4IHBvc2l0aW9uIGZvciBrZXkgdG8gYmUgcmV0dXJuZWQgKHN0YXJ0cyBhdCAwKS5cbiAgICovXG4gIHB1YmxpYyBrZXkoaW5kZXg6IG51bWJlcik6IHN0cmluZyB8IG51bGwge1xuICAgIHJldHVybiBPYmplY3Qua2V5cyh0aGlzLl9jYWNoZSlbaW5kZXhdIHx8IG51bGxcbiAgfVxuXG4gIC8qKlxuICAgKiBSZW1vdmVzIGl0ZW0gZm9yIHBhc3NlZCBrZXkuXG4gICAqXG4gICAqIEBwYXJhbSBrZXkgbmFtZSBvZiBpdGVtIHRvIGJlIHJlbW92ZWQuXG4gICAqL1xuICBwdWJsaWMgcmVtb3ZlSXRlbShrZXk6IHN0cmluZyk6IHZvaWQge1xuICAgIGlmICh0aGlzLl9jYWNoZS5oYXNPd25Qcm9wZXJ0eShrZXkpKSB7XG4gICAgICBkZWxldGUgdGhpcy5fY2FjaGVba2V5XVxuICAgICAgdGhpcy5sZW5ndGgtLVxuICAgIH1cbiAgfVxuXG4gIC8qKlxuICAgKiBTZXRzIGl0ZW0gZm9yIGtleSB0byBwYXNzZWQgdmFsdWUsIGFzIHN0cmluZy5cbiAgICpcbiAgICogQHBhcmFtIGtleSBuYW1lIG9mIGl0ZW0gdG8gYmUgc2V0LlxuICAgKiBAcGFyYW0gdmFsdWUgdmFsdWUsIHdpbGwgYWx3YXlzIGJlIHR1cm5lZCBpbnRvIGEgc3RyaW5nLlxuICAgKi9cbiAgcHVibGljIHNldEl0ZW0oa2V5OiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcpOiB2b2lkIHtcbiAgICBpZiAodHlwZW9mIHZhbHVlID09PSAndW5kZWZpbmVkJykge1xuICAgICAgdGhpcy5yZW1vdmVJdGVtKGtleSlcbiAgICB9IGVsc2Uge1xuICAgICAgaWYgKCF0aGlzLl9jYWNoZS5oYXNPd25Qcm9wZXJ0eShrZXkpKSB7XG4gICAgICAgIHRoaXMubGVuZ3RoKytcbiAgICAgIH1cblxuICAgICAgdGhpcy5fY2FjaGVba2V5XSA9ICcnICsgdmFsdWVcbiAgICB9XG4gIH1cblxufVxuIl19