@theseam/ui-common 0.3.15-beta.0 → 0.3.15-beta.1

package/esm2020/datatable-dynamic/directives/datatable-dynamic-action-menu-item.directive.mjs

@@ -0,0 +1,400 @@
+import { __decorate, __param } from "tslib";
+import { Attribute, Directive, Input, isDevMode, } from '@angular/core';
+import { RouterLink, RouterLinkWithHref } from '@angular/router';
+import { from, fromEvent, of, ReplaySubject, Subscription } from 'rxjs';
+import { catchError, mapTo, switchMap, tap } from 'rxjs/operators';
+import { getAttribute, hasProperty, toggleAttribute } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/dynamic";
+import * as i2 from "@theseam/ui-common/asset-reader";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/common";
+/**
+ * Class to act as a substitute to `routerLink` directive until the menu items
+ * can be dynamically built in a clean way with or without `routerLink`.
+ */
+let DatatableDynamicActionMenuItemRouterLink = class DatatableDynamicActionMenuItemRouterLink {
+    constructor(router, route, tabIndex, renderer, el, locationStrategy) {
+        this.router = router;
+        this.route = route;
+        this.renderer = renderer;
+        this.el = el;
+        this.locationStrategy = locationStrategy;
+        if (el.nativeElement.nodeName.toLowerCase() === 'a') {
+            this._rLinkWithHref = new RouterLinkWithHref(router, route, '0', // TODO: Fix type.
+            renderer, el.nativeElement, locationStrategy);
+            // console.log('rLinkWithHref', this.rLinkWithHref)
+            this._rLinkClickEventListener = this.el.nativeElement.addEventListener('click', (event) => {
+                // console.log('this._rLinkWithHref', this._rLinkWithHref, this._rLinkWithHref && this._rLinkWithHref.href)
+                if (this._rLinkWithHref) {
+                    return this._rLinkWithHref.onClick(event.button, event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
+                }
+            });
+        }
+        else {
+            this._rLink = new RouterLink(router, route, tabIndex, renderer, el);
+            // console.log('rLink', this.rLink)
+            this._rLinkClickEventListener = this.el.nativeElement.addEventListener('click', () => {
+                // console.log('this._rLink', this._rLink && this._rLink.urlTree)
+                if (this._rLink) {
+                    return this._rLink.onClick();
+                }
+            });
+            // this._clickSubscription = fromEvent(el.nativeElement, 'click')
+            //   .subscribe(() => {
+            //     if (this._rLink) {
+            //       this._rLink.onClick()
+            //     } else {
+            //       if (this._clickSubscription && !this._clickSubscription.closed) {
+            //         this._clickSubscription.unsubscribe()
+            //       }
+            //     }
+            //   })
+        }
+    }
+    get routerLink() { return this._rLink; }
+    get routerLinkWithHref() { return this._rLinkWithHref; }
+    set routerLinkInput(commands) {
+        if (this._rLink) {
+            this._rLink.routerLink = commands;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.routerLink = commands;
+        }
+    }
+    set queryParams(value) {
+        if (this._rLink) {
+            this._rLink.queryParams = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.queryParams = value;
+        }
+    }
+    set fragment(value) {
+        if (this._rLink) {
+            this._rLink.fragment = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.fragment = value;
+        }
+    }
+    set queryParamsHandling(value) {
+        if (this._rLink) {
+            this._rLink.queryParamsHandling = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.queryParamsHandling = value;
+        }
+    }
+    set preserveFragment(value) {
+        if (this._rLink) {
+            this._rLink.preserveFragment = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.preserveFragment = value;
+        }
+    }
+    set skipLocationChange(value) {
+        if (this._rLink) {
+            this._rLink.skipLocationChange = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.skipLocationChange = value;
+        }
+    }
+    set replaceUrl(value) {
+        if (this._rLink) {
+            this._rLink.replaceUrl = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.replaceUrl = value;
+        }
+    }
+    set state(value) {
+        if (this._rLink) {
+            this._rLink.state = value;
+        }
+        else if (this._rLinkWithHref) {
+            this._rLinkWithHref.state = value;
+        }
+    }
+    set target(value) {
+        if (this._rLinkWithHref) {
+            this._rLinkWithHref.target = value;
+            if (value) {
+                this.renderer.setAttribute(this.el.nativeElement, 'target', value);
+            }
+            else {
+                toggleAttribute(this.el.nativeElement, 'target', false);
+            }
+        }
+    }
+    destroy() {
+        // if (this._clickSubscription && !this._clickSubscription.closed) {
+        //   this._clickSubscription.unsubscribe()
+        // }
+        if (this._rLinkClickEventListener) {
+            this.el.nativeElement.removeEventListener('click', this._rLinkClickEventListener);
+            this._rLinkClickEventListener = null;
+        }
+        if (this._rLinkWithHref && this._rLinkWithHref.ngOnDestroy) {
+            this._rLinkWithHref.ngOnDestroy();
+        }
+    }
+};
+DatatableDynamicActionMenuItemRouterLink = __decorate([
+    __param(2, Attribute('tabindex'))
+], DatatableDynamicActionMenuItemRouterLink);
+export { DatatableDynamicActionMenuItemRouterLink };
+// TODO: Refactor this directive. It got way more complex instead of more
+// simplified like it was supposed to be.
+export class DatatableDynamicActionMenuItemDirective {
+    set seamDatatableDynamicActionMenuItem(value) {
+        this._record.next(value);
+    }
+    constructor(_elementRef, _renderer, _valueHelper, _actionHelper, _assetReaderHelper, _router, _route, _locationStrategy) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this._valueHelper = _valueHelper;
+        this._actionHelper = _actionHelper;
+        this._assetReaderHelper = _assetReaderHelper;
+        this._router = _router;
+        this._route = _route;
+        this._locationStrategy = _locationStrategy;
+        this._record = new ReplaySubject(1);
+        this._recordSubscription = Subscription.EMPTY;
+        this._recordSubscription = this._record.pipe(
+        // tap(v => console.log('record', v)),
+        switchMap(record => this._update(record)), tap(() => { this._setInvalidActionState(false); }), catchError(error => {
+            // eslint-disable-next-line no-console
+            if (isDevMode()) {
+                console.error(error);
+            }
+            this._setInvalidActionState(true);
+            return of(undefined);
+        })).subscribe();
+    }
+    ngOnDestroy() {
+        this._recordSubscription.unsubscribe();
+        this._unsubClick();
+        if (this._menuRouterLink && this._menuRouterLink.routerLinkWithHref) {
+            this._menuRouterLink.routerLinkWithHref.ngOnDestroy();
+        }
+    }
+    ngOnChanges(changes) {
+        // console.log('ngOnChanges', changes, this, this._menuRouterLink)
+        if (this._menuRouterLink && this._menuRouterLink.routerLinkWithHref) {
+            this._menuRouterLink.routerLinkWithHref.ngOnChanges({});
+            if (this._menuRouterLink.routerLinkWithHref.href) {
+                if (getAttribute(this._elementRef.nativeElement, 'href') !== this._menuRouterLink.routerLinkWithHref.href) {
+                    this._renderer.setAttribute(this._elementRef.nativeElement, 'href', this._menuRouterLink.routerLinkWithHref.href);
+                }
+            }
+            else {
+                toggleAttribute(this._elementRef.nativeElement, 'href', false);
+            }
+        }
+    }
+    _update(record) {
+        this._unsubClick();
+        return from(this._getUiProps(record)).pipe(switchMap(uiProps => this._isAnchor()
+            ? this._updateAnchorElement(record, uiProps)
+            : this._updateButtonElement(record, uiProps)));
+    }
+    _updateAnchorElement(record, uiProps) {
+        const _stream = of(undefined);
+        switch (uiProps.triggerType) {
+            case 'link': {
+                // console.log('Handle "link" triggerType.', uiProps)
+                // this._tryInitTabIndex()
+                this._tryInitBlockClick(record, uiProps);
+                this._initMenuItemRouterLink(record, uiProps);
+                break;
+            }
+            case 'link-external': {
+                // console.log('Handle "link-external" triggerType.', uiProps)
+                // this._tryInitTabIndex()
+                this._tryInitBlockClick(record, uiProps);
+                if (hasProperty(uiProps, 'linkUrl')) {
+                    this._setAttr('href', uiProps.linkUrl);
+                }
+                if (hasProperty(uiProps, 'linkExtras')) {
+                    if (hasProperty(uiProps.linkExtras, 'target')) {
+                        this._setAttr('target', uiProps.linkExtras.target);
+                    }
+                }
+                // TODO: Consider making the ItemRouterLink work with external urls.
+                // this._initMenuItemRouterLink(record, uiProps)
+                break;
+            }
+            // TODO: Unless we decide to add a route for openning assets, this would
+            // be confusing to a user.
+            // case 'link-asset': {
+            //   console.log('Handle "link-asset" triggerType.', uiProps)
+            //   // this._tryInitTabIndex()
+            //   this._tryInitBlockClick(record, uiProps)
+            //   break
+            // }
+            default: throw Error('[DatatableDynamicActionMenuItemDirective] ' +
+                `triggerType ${uiProps.triggerType} is not valid for _updateAnchorElement().`);
+        }
+        return _stream; // .pipe(mapTo(undefined))
+    }
+    _updateButtonElement(record, uiProps) {
+        let _stream = of(undefined);
+        // this._updateClickElement(record, uiProps as DynamicActionUiButtonDef)
+        switch (uiProps.triggerType) {
+            case 'link-asset': {
+                // console.log('Handle "link-asset" triggerType.', uiProps)
+                // this._tryInitTabIndex()
+                this._tryInitBlockClick(record, uiProps);
+                _stream = _stream.pipe(switchMap(() => this._updateAssetElement(record, uiProps)));
+                break;
+            }
+            case 'click': {
+                // console.log('Handle "click" triggerType.', uiProps)
+                this._tryInitBlockClick(record, uiProps);
+                _stream = _stream.pipe(switchMap(() => this._updateClickElement(record, uiProps)));
+                break;
+            }
+            default: throw Error('[DatatableDynamicActionMenuItemDirective] ' +
+                `triggerType ${uiProps.triggerType} is not valid for _updateAnchorElement().`);
+        }
+        return _stream; // .pipe(mapTo(undefined))
+    }
+    _updateAssetElement(record, uiProps) {
+        // console.log('_updateAssetElement')
+        // return of(undefined)
+        // console.log('this._elementRef.nativeElement', this._elementRef.nativeElement)
+        const t = fromEvent(this._elementRef.nativeElement, 'click').pipe(tap(event => {
+            // const _context = this._getContext(record._row, record.rowAction)
+            // const context = { ..._context, event, uiProps }
+            // const result = this._valueHelper.evalSync(uiProps.blockClickExpr, context)
+            // console.log(record, uiProps)
+            // console.log('_updateClickElement click', (<any>event).button, event)
+            if (this._assetReaderHelper) {
+                if (uiProps.triggerType === 'link-asset' && hasProperty(uiProps, 'linkUrl')) {
+                    const url = uiProps.linkUrl;
+                    let target;
+                    if (hasProperty(uiProps, 'linkExtras') && hasProperty(uiProps.linkExtras, 'target')) {
+                        target = uiProps.linkExtras.target;
+                    }
+                    this._assetReaderHelper.openLink(url, true, true, target);
+                }
+            }
+            // if (!result) {
+            //   event.preventDefault()
+            //   event.stopPropagation()
+            // }
+        }), mapTo(undefined));
+        return of(undefined).pipe(
+        // tap(() => console.log('starting _updateButtonElement')),
+        switchMap(() => t));
+    }
+    _updateClickElement(record, uiProps) {
+        // console.log('_updateClickElement', record, uiProps)
+        // return of(undefined)
+        return fromEvent(this._elementRef.nativeElement, 'click').pipe(switchMap(event => {
+            const _context = this._getContext(record._row, record.rowAction);
+            const context = { ..._context, event, uiProps };
+            // console.log('click', (<any>event).button, event)
+            // if (!result) {
+            //   event.preventDefault()
+            //   event.stopPropagation()
+            // }
+            return this._actionHelper.exec(uiProps._actionDef, context);
+        }), mapTo(undefined));
+    }
+    _unsubClick() {
+        if (this._clickSubscription && !this._clickSubscription.closed) {
+            this._clickSubscription.unsubscribe();
+        }
+    }
+    _setAttr(attr, value) {
+        this._renderer.setAttribute(this._elementRef.nativeElement, attr, value);
+    }
+    _tryInitTabIndex() {
+        if (getAttribute(this._elementRef.nativeElement, 'tabindex') === null) {
+            this._renderer.setAttribute(this._elementRef.nativeElement, 'tabindex', '0');
+        }
+    }
+    _tryInitBlockClick(record, uiProps) {
+        this._unsubClick();
+        if (hasProperty(uiProps, 'blockClickExpr')) {
+            this._clickSubscription = this._blockClickExprObservable(uiProps, record).subscribe();
+        }
+    }
+    _blockClickExprObservable(uiProps, record) {
+        return fromEvent(this._elementRef.nativeElement, 'click').pipe(tap(event => {
+            const _context = this._getContext(record._row, record.rowAction);
+            const context = { ..._context, event, uiProps };
+            const result = this._valueHelper.evalSync(uiProps.blockClickExpr, context);
+            // console.log('click', result, (<any>event).button, event)
+            if (!result) {
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        }), mapTo(undefined));
+    }
+    _initMenuItemRouterLink(record, uiProps) {
+        this._menuRouterLink = new DatatableDynamicActionMenuItemRouterLink(this._router, this._route, getAttribute(this._elementRef.nativeElement, 'tabindex'), this._renderer, this._elementRef, this._locationStrategy);
+        // console.log(this._menuRouterLink)
+        this._menuRouterLink.routerLinkInput = uiProps.linkUrl;
+        if (hasProperty(uiProps, 'linkExtras')) {
+            if (hasProperty(uiProps.linkExtras, 'target')) {
+                this._menuRouterLink.target = uiProps.linkExtras.target;
+            }
+            if (hasProperty(uiProps.linkExtras, 'queryParams')) {
+                this._menuRouterLink.queryParams = uiProps.linkExtras.queryParams;
+            }
+            if (hasProperty(uiProps.linkExtras, 'fragment')) {
+                this._menuRouterLink.fragment = uiProps.linkExtras.fragment;
+            }
+            if (hasProperty(uiProps.linkExtras, 'queryParamsHandling')) {
+                this._menuRouterLink.queryParamsHandling = uiProps.linkExtras.queryParamsHandling;
+            }
+            if (hasProperty(uiProps.linkExtras, 'preserveFragment')) {
+                this._menuRouterLink.preserveFragment = uiProps.linkExtras.preserveFragment;
+            }
+            if (hasProperty(uiProps.linkExtras, 'skipLocationChange')) {
+                this._menuRouterLink.skipLocationChange = uiProps.linkExtras.skipLocationChange;
+            }
+            if (hasProperty(uiProps.linkExtras, 'replaceUrl')) {
+                this._menuRouterLink.replaceUrl = uiProps.linkExtras.replaceUrl;
+            }
+            if (hasProperty(uiProps.linkExtras, 'state')) {
+                this._menuRouterLink.state = uiProps.linkExtras.state;
+            }
+        }
+        this.ngOnChanges({});
+    }
+    _isAnchor() {
+        return this._elementRef.nativeElement.nodeName.toLowerCase() === 'a';
+    }
+    _getUiProps(record) {
+        const context = this._getContext(record._row, record.rowAction);
+        return this._actionHelper.getUiProps(record.rowAction.action, context);
+    }
+    /** @ignore */
+    _getContext(row, rowActionDef) {
+        return {
+            row
+        };
+    }
+    _setInvalidActionState(invalid = false) {
+        const element = this._elementRef.nativeElement;
+        toggleAttribute(element, 'disabled', invalid);
+    }
+}
+DatatableDynamicActionMenuItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatatableDynamicActionMenuItemDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.DynamicValueHelperService }, { token: i1.DynamicActionHelperService }, { token: i2.AssetReaderHelperService }, { token: i3.Router }, { token: i3.ActivatedRoute }, { token: i4.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableDynamicActionMenuItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: DatatableDynamicActionMenuItemDirective, selector: "[seamDatatableDynamicActionMenuItem]", inputs: { seamDatatableDynamicActionMenuItem: "seamDatatableDynamicActionMenuItem" }, exportAs: ["seamDatatableDynamicActionMenuItem"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatatableDynamicActionMenuItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDatatableDynamicActionMenuItem]',
+                    exportAs: 'seamDatatableDynamicActionMenuItem'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.DynamicValueHelperService }, { type: i1.DynamicActionHelperService }, { type: i2.AssetReaderHelperService }, { type: i3.Router }, { type: i3.ActivatedRoute }, { type: i4.LocationStrategy }]; }, propDecorators: { seamDatatableDynamicActionMenuItem: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-dynamic-action-menu-item.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable-dynamic/directives/datatable-dynamic-action-menu-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { LocationStrategy } from '@angular/common'\nimport {\n  Attribute,\n  Directive,\n  ElementRef,\n  Input,\n  isDevMode,\n  OnChanges,\n  OnDestroy,\n  Renderer2,\n  SimpleChanges,\n} from '@angular/core'\nimport { ActivatedRoute, QueryParamsHandling, Router, RouterLink, RouterLinkWithHref } from '@angular/router'\nimport { from, fromEvent, Observable, of, ReplaySubject, Subscription } from 'rxjs'\nimport { catchError, mapTo, switchMap, tap } from 'rxjs/operators'\n\nimport { AssetReaderHelperService } from '@theseam/ui-common/asset-reader'\nimport {\n  DynamicActionHelperService,\n  DynamicActionUiAnchorDef,\n  DynamicActionUiButtonDef,\n  DynamicActionUiDef,\n  DynamicValueHelperService\n} from '@theseam/ui-common/dynamic'\nimport { getAttribute, hasProperty, toggleAttribute } from '@theseam/ui-common/utils'\n\nimport { DynamicDatatableRow } from '../datatable-dynamic-def'\nimport type { DynamicDatatableActionMenuRecord } from '../models/dynamic-datatable-action-menu-record'\nimport { DynamicDatatableRowAction } from '../models/dynamic-datatable-row-action'\nimport { DynamicDatatableRowActionContext } from '../models/dynamic-datatable-row-action-context'\n\n/**\n * Class to act as a substitute to `routerLink` directive until the menu items\n * can be dynamically built in a clean way with or without `routerLink`.\n */\nexport class DatatableDynamicActionMenuItemRouterLink {\n\n  private _rLink?: RouterLink\n  private _rLinkWithHref?: RouterLinkWithHref\n\n  // private _clickSubscription?: Subscription\n  private _rLinkClickEventListener?: any\n\n  constructor(\n    private router: Router,\n    private route: ActivatedRoute,\n    @Attribute('tabindex') tabIndex: string | null,\n    private renderer: Renderer2,\n    private el: ElementRef,\n    private locationStrategy: LocationStrategy\n  ) {\n    if (el.nativeElement.nodeName.toLowerCase() === 'a') {\n      this._rLinkWithHref = new RouterLinkWithHref(\n        router,\n        route,\n        '0', // TODO: Fix type.\n        renderer,\n        el.nativeElement,\n        locationStrategy\n      )\n      // console.log('rLinkWithHref', this.rLinkWithHref)\n\n      this._rLinkClickEventListener = this.el.nativeElement.addEventListener('click', (event: MouseEvent) => {\n        // console.log('this._rLinkWithHref', this._rLinkWithHref, this._rLinkWithHref && this._rLinkWithHref.href)\n        if (this._rLinkWithHref) {\n          return this._rLinkWithHref.onClick(event.button, event.ctrlKey, event.shiftKey, event.altKey, event.metaKey)\n        }\n      })\n    } else {\n      this._rLink = new RouterLink(\n        router,\n        route,\n        tabIndex as string,\n        renderer,\n        el\n      )\n      // console.log('rLink', this.rLink)\n\n      this._rLinkClickEventListener = this.el.nativeElement.addEventListener('click', () => {\n        // console.log('this._rLink', this._rLink && this._rLink.urlTree)\n        if (this._rLink) { return (this._rLink as any).onClick() }\n      })\n\n      // this._clickSubscription = fromEvent(el.nativeElement, 'click')\n      //   .subscribe(() => {\n      //     if (this._rLink) {\n      //       this._rLink.onClick()\n      //     } else {\n      //       if (this._clickSubscription && !this._clickSubscription.closed) {\n      //         this._clickSubscription.unsubscribe()\n      //       }\n      //     }\n      //   })\n    }\n  }\n\n  get routerLink(): RouterLink | undefined { return this._rLink }\n  get routerLinkWithHref(): RouterLinkWithHref | undefined { return this._rLinkWithHref }\n\n  set routerLinkInput(commands: any[] | string) {\n    if (this._rLink) {\n      this._rLink.routerLink = commands\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.routerLink = commands\n    }\n  }\n\n  set queryParams(value: { [k: string]: any }) {\n    if (this._rLink) {\n      this._rLink.queryParams = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.queryParams = value\n    }\n  }\n\n  set fragment(value: string) {\n    if (this._rLink) {\n      this._rLink.fragment = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.fragment = value\n    }\n  }\n\n  set queryParamsHandling(value: QueryParamsHandling) {\n    if (this._rLink) {\n      this._rLink.queryParamsHandling = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.queryParamsHandling = value\n    }\n  }\n\n  set preserveFragment(value: boolean) {\n    if (this._rLink) {\n      this._rLink.preserveFragment = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.preserveFragment = value\n    }\n  }\n\n  set skipLocationChange(value: boolean) {\n    if (this._rLink) {\n      this._rLink.skipLocationChange = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.skipLocationChange = value\n    }\n  }\n\n  set replaceUrl(value: boolean) {\n    if (this._rLink) {\n      this._rLink.replaceUrl = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.replaceUrl = value\n    }\n  }\n\n  set state(value: { [k: string]: any }) {\n    if (this._rLink) {\n      this._rLink.state = value\n    } else if (this._rLinkWithHref) {\n      this._rLinkWithHref.state = value\n    }\n  }\n\n  set target(value: string | undefined) {\n    if (this._rLinkWithHref) {\n      this._rLinkWithHref.target = value as string\n\n      if (value) {\n        this.renderer.setAttribute(this.el.nativeElement, 'target', value)\n      } else {\n        toggleAttribute(this.el.nativeElement, 'target', false)\n      }\n    }\n  }\n\n  public destroy() {\n    // if (this._clickSubscription && !this._clickSubscription.closed) {\n    //   this._clickSubscription.unsubscribe()\n    // }\n    if (this._rLinkClickEventListener) {\n      this.el.nativeElement.removeEventListener('click', this._rLinkClickEventListener)\n      this._rLinkClickEventListener = null\n    }\n\n    if (this._rLinkWithHref && this._rLinkWithHref.ngOnDestroy) {\n      this._rLinkWithHref.ngOnDestroy()\n    }\n  }\n\n}\n\n// TODO: Refactor this directive. It got way more complex instead of more\n// simplified like it was supposed to be.\n@Directive({\n  selector: '[seamDatatableDynamicActionMenuItem]',\n  exportAs: 'seamDatatableDynamicActionMenuItem'\n})\nexport class DatatableDynamicActionMenuItemDirective implements OnDestroy, OnChanges {\n\n  @Input()\n  // get seamDatatableDynamicActionMenuItem(): DynamicDatatableActionMenuRecord { return this._record }\n  set seamDatatableDynamicActionMenuItem(value: DynamicDatatableActionMenuRecord) {\n    this._record.next(value)\n  }\n  private _record = new ReplaySubject<DynamicDatatableActionMenuRecord>(1)\n\n  private _clickSubscription?: Subscription\n  private _menuRouterLink?: DatatableDynamicActionMenuItemRouterLink\n\n  private _recordSubscription = Subscription.EMPTY\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _renderer: Renderer2,\n    private _valueHelper: DynamicValueHelperService,\n    private _actionHelper: DynamicActionHelperService,\n    private _assetReaderHelper: AssetReaderHelperService,\n    private _router: Router,\n    private _route: ActivatedRoute,\n    private _locationStrategy: LocationStrategy\n  ) {\n    this._recordSubscription = this._record.pipe(\n      // tap(v => console.log('record', v)),\n      switchMap(record => this._update(record)),\n      tap(() => { this._setInvalidActionState(false) }),\n      catchError(error => {\n        // eslint-disable-next-line no-console\n        if (isDevMode()) { console.error(error) }\n        this._setInvalidActionState(true)\n        return of(undefined)\n      }),\n      // tap(v => console.log('record DONE', v))\n    ).subscribe()\n  }\n\n  ngOnDestroy() {\n    this._recordSubscription.unsubscribe()\n    this._unsubClick()\n    if (this._menuRouterLink && this._menuRouterLink.routerLinkWithHref) {\n      this._menuRouterLink.routerLinkWithHref.ngOnDestroy()\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    // console.log('ngOnChanges', changes, this, this._menuRouterLink)\n    if (this._menuRouterLink && this._menuRouterLink.routerLinkWithHref) {\n      this._menuRouterLink.routerLinkWithHref.ngOnChanges({})\n      if (this._menuRouterLink.routerLinkWithHref.href) {\n        if (getAttribute(this._elementRef.nativeElement, 'href') !== this._menuRouterLink.routerLinkWithHref.href) {\n          this._renderer.setAttribute(this._elementRef.nativeElement, 'href', this._menuRouterLink.routerLinkWithHref.href)\n        }\n      } else {\n        toggleAttribute(this._elementRef.nativeElement, 'href', false)\n      }\n    }\n  }\n\n  public _update(record: DynamicDatatableActionMenuRecord): Observable<void> {\n    this._unsubClick()\n\n    return from(this._getUiProps(record)).pipe(\n      switchMap(uiProps => this._isAnchor()\n        ? this._updateAnchorElement(record, uiProps as DynamicActionUiAnchorDef)\n        : this._updateButtonElement(record, uiProps as DynamicActionUiButtonDef)\n      )\n    )\n  }\n\n  private _updateAnchorElement(\n    record: DynamicDatatableActionMenuRecord,\n    uiProps: DynamicActionUiAnchorDef\n  ): Observable<void> {\n    const _stream: Observable<any> = of(undefined)\n\n    switch (uiProps.triggerType) {\n      case 'link': {\n        // console.log('Handle \"link\" triggerType.', uiProps)\n        // this._tryInitTabIndex()\n        this._tryInitBlockClick(record, uiProps)\n        this._initMenuItemRouterLink(record, uiProps)\n\n        break\n      }\n      case 'link-external': {\n        // console.log('Handle \"link-external\" triggerType.', uiProps)\n        // this._tryInitTabIndex()\n        this._tryInitBlockClick(record, uiProps)\n        if (hasProperty(uiProps, 'linkUrl')) {\n          this._setAttr('href', uiProps.linkUrl)\n        }\n        if (hasProperty(uiProps, 'linkExtras')) {\n          if (hasProperty(uiProps.linkExtras, 'target')) {\n            this._setAttr('target', uiProps.linkExtras.target)\n          }\n        }\n        // TODO: Consider making the ItemRouterLink work with external urls.\n        // this._initMenuItemRouterLink(record, uiProps)\n\n        break\n      }\n      // TODO: Unless we decide to add a route for openning assets, this would\n      // be confusing to a user.\n      // case 'link-asset': {\n      //   console.log('Handle \"link-asset\" triggerType.', uiProps)\n      //   // this._tryInitTabIndex()\n      //   this._tryInitBlockClick(record, uiProps)\n      //   break\n      // }\n      default: throw Error('[DatatableDynamicActionMenuItemDirective] ' +\n        `triggerType ${uiProps.triggerType} is not valid for _updateAnchorElement().`)\n    }\n\n    return _stream// .pipe(mapTo(undefined))\n  }\n\n  private _updateButtonElement(\n    record: DynamicDatatableActionMenuRecord,\n    uiProps: DynamicActionUiAnchorDef | DynamicActionUiButtonDef\n  ): Observable<void> {\n    let _stream: Observable<any> = of(undefined)\n    // this._updateClickElement(record, uiProps as DynamicActionUiButtonDef)\n    switch (uiProps.triggerType) {\n      case 'link-asset': {\n        // console.log('Handle \"link-asset\" triggerType.', uiProps)\n        // this._tryInitTabIndex()\n        this._tryInitBlockClick(record, uiProps)\n        _stream = _stream.pipe(switchMap(() => this._updateAssetElement(record, uiProps)))\n        break\n      }\n      case 'click': {\n        // console.log('Handle \"click\" triggerType.', uiProps)\n        this._tryInitBlockClick(record, uiProps)\n        _stream = _stream.pipe(switchMap(() => this._updateClickElement(record, uiProps)))\n        break\n      }\n      default: throw Error('[DatatableDynamicActionMenuItemDirective] ' +\n        `triggerType ${uiProps.triggerType} is not valid for _updateAnchorElement().`)\n    }\n\n    return _stream// .pipe(mapTo(undefined))\n  }\n\n  private _updateAssetElement(\n    record: DynamicDatatableActionMenuRecord,\n    uiProps: DynamicActionUiAnchorDef | DynamicActionUiButtonDef\n  ): Observable<void> {\n    // console.log('_updateAssetElement')\n    // return of(undefined)\n    // console.log('this._elementRef.nativeElement', this._elementRef.nativeElement)\n    const t = fromEvent(this._elementRef.nativeElement, 'click').pipe(\n      tap(event => {\n        // const _context = this._getContext(record._row, record.rowAction)\n        // const context = { ..._context, event, uiProps }\n        // const result = this._valueHelper.evalSync(uiProps.blockClickExpr, context)\n        // console.log(record, uiProps)\n        // console.log('_updateClickElement click', (<any>event).button, event)\n        if (this._assetReaderHelper) {\n          if (uiProps.triggerType === 'link-asset' && hasProperty(uiProps, 'linkUrl')) {\n            const url = uiProps.linkUrl\n            let target: string | undefined\n            if (hasProperty(uiProps, 'linkExtras') && hasProperty(uiProps.linkExtras, 'target')) {\n              target = uiProps.linkExtras.target\n            }\n            this._assetReaderHelper.openLink(url, true, true, target)\n          }\n        }\n        // if (!result) {\n        //   event.preventDefault()\n        //   event.stopPropagation()\n        // }\n      }),\n      mapTo(undefined)\n    )\n\n    return of(undefined).pipe(\n      // tap(() => console.log('starting _updateButtonElement')),\n      switchMap(() => t),\n    )\n  }\n\n  private _updateClickElement(\n    record: DynamicDatatableActionMenuRecord,\n    uiProps: DynamicActionUiButtonDef\n  ): Observable<void> {\n    // console.log('_updateClickElement', record, uiProps)\n    // return of(undefined)\n    return fromEvent(this._elementRef.nativeElement, 'click').pipe(\n      switchMap(event => {\n        const _context = this._getContext(record._row, record.rowAction)\n        const context = { ..._context, event, uiProps }\n        // console.log('click', (<any>event).button, event)\n        // if (!result) {\n        //   event.preventDefault()\n        //   event.stopPropagation()\n        // }\n\n        return this._actionHelper.exec(uiProps._actionDef, context)\n      }),\n      mapTo(undefined)\n    )\n  }\n\n  private _unsubClick() {\n    if (this._clickSubscription && !this._clickSubscription.closed) {\n      this._clickSubscription.unsubscribe()\n    }\n  }\n\n  private _setAttr(attr: string, value: string) {\n    this._renderer.setAttribute(this._elementRef.nativeElement, attr, value)\n  }\n\n  private _tryInitTabIndex() {\n    if (getAttribute(this._elementRef.nativeElement, 'tabindex') === null) {\n      this._renderer.setAttribute(this._elementRef.nativeElement, 'tabindex', '0')\n    }\n  }\n\n  private _tryInitBlockClick(\n    record: DynamicDatatableActionMenuRecord,\n    uiProps: DynamicActionUiDef\n  ) {\n    this._unsubClick()\n    if (hasProperty(uiProps, 'blockClickExpr')) {\n      this._clickSubscription = this._blockClickExprObservable(uiProps, record).subscribe()\n    }\n  }\n\n  private _blockClickExprObservable(\n    uiProps: DynamicActionUiDef,\n    record: DynamicDatatableActionMenuRecord\n  ) {\n    return fromEvent(this._elementRef.nativeElement, 'click').pipe(\n      tap(event => {\n        const _context = this._getContext(record._row, record.rowAction)\n        const context = { ..._context, event, uiProps }\n        const result = this._valueHelper.evalSync(uiProps.blockClickExpr, context)\n        // console.log('click', result, (<any>event).button, event)\n        if (!result) {\n          event.preventDefault()\n          event.stopPropagation()\n        }\n      }),\n      mapTo(undefined)\n    )\n  }\n\n  private _initMenuItemRouterLink(\n    record: DynamicDatatableActionMenuRecord,\n    uiProps: DynamicActionUiAnchorDef\n  ) {\n    this._menuRouterLink = new DatatableDynamicActionMenuItemRouterLink(\n      this._router,\n      this._route,\n      getAttribute(this._elementRef.nativeElement, 'tabindex'),\n      this._renderer,\n      this._elementRef,\n      this._locationStrategy\n    )\n    // console.log(this._menuRouterLink)\n\n    this._menuRouterLink.routerLinkInput = uiProps.linkUrl as string\n\n    if (hasProperty(uiProps, 'linkExtras')) {\n      if (hasProperty(uiProps.linkExtras, 'target')) {\n        this._menuRouterLink.target = uiProps.linkExtras.target\n      }\n      if (hasProperty(uiProps.linkExtras, 'queryParams')) {\n        this._menuRouterLink.queryParams = uiProps.linkExtras.queryParams\n      }\n      if (hasProperty(uiProps.linkExtras, 'fragment')) {\n        this._menuRouterLink.fragment = uiProps.linkExtras.fragment\n      }\n      if (hasProperty(uiProps.linkExtras, 'queryParamsHandling')) {\n        this._menuRouterLink.queryParamsHandling = uiProps.linkExtras.queryParamsHandling\n      }\n      if (hasProperty(uiProps.linkExtras, 'preserveFragment')) {\n        this._menuRouterLink.preserveFragment = uiProps.linkExtras.preserveFragment\n      }\n      if (hasProperty(uiProps.linkExtras, 'skipLocationChange')) {\n        this._menuRouterLink.skipLocationChange = uiProps.linkExtras.skipLocationChange\n      }\n      if (hasProperty(uiProps.linkExtras, 'replaceUrl')) {\n        this._menuRouterLink.replaceUrl = uiProps.linkExtras.replaceUrl\n      }\n      if (hasProperty(uiProps.linkExtras, 'state')) {\n        this._menuRouterLink.state = uiProps.linkExtras.state\n      }\n    }\n\n    this.ngOnChanges({})\n  }\n\n  private _isAnchor(): boolean {\n    return this._elementRef.nativeElement.nodeName.toLowerCase() === 'a'\n  }\n\n  private _getUiProps(record: DynamicDatatableActionMenuRecord): Promise<DynamicActionUiDef> {\n    const context = this._getContext(record._row, record.rowAction)\n    return this._actionHelper.getUiProps(record.rowAction.action, context)\n  }\n\n  /** @ignore */\n  private _getContext(row: DynamicDatatableRow, rowActionDef: DynamicDatatableRowAction): DynamicDatatableRowActionContext {\n    return {\n      row\n    }\n  }\n\n  private _setInvalidActionState(invalid: boolean = false) {\n    const element = this._elementRef.nativeElement\n    toggleAttribute(element, 'disabled', invalid)\n  }\n\n}\n"]}

package/esm2020/datatable-dynamic/dynamic-datatable-def.service.mjs

@@ -0,0 +1,88 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, of } from 'rxjs';
+import { map, shareReplay, switchMap } from 'rxjs/operators';
+import { THESEAM_DATA_EXPORTER } from '@theseam/ui-common/data-exporter';
+import { THESEAM_DATA_FILTER_DEF } from '@theseam/ui-common/data-filters';
+import { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { setDynamicDatatableDefDefaults } from './utils/index';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/dynamic";
+/**
+ * Manages the data defined in the `DatatableDynamicDef`. Simplifies accessing
+ * and observing the needed data based on the `DatatableDynamicDef`.
+ */
+export class DynamicDatatableDefService {
+    constructor(dataExporters, dataFilters, _valueHelper) {
+        this._valueHelper = _valueHelper;
+        /** @ignore */
+        this._defSubject = new BehaviorSubject(undefined);
+        this._dataExporters = (dataExporters || []);
+        this._dataFilters = (dataFilters || []);
+        this.def$ = this._defSubject.asObservable();
+        this.exporters$ = this.def$.pipe(map(def => def ? this._mapExporters(def) : []), shareReplay({ bufferSize: 1, refCount: true }));
+        this.filterMenuItems$ = this.def$.pipe(map(def => def ? this._mapFilterMenuItems(def) : []), shareReplay({ bufferSize: 1, refCount: true }));
+        this.hasFilterMenu$ = this.def$.pipe(switchMap(def => {
+            if (!def) {
+                return of(false);
+            }
+            // Check if the visibility can be determined by the state value only.
+            if (def.filterMenu && def.filterMenu.state) {
+                switch (def.filterMenu.state) {
+                    case 'always-visible': return of(true);
+                    case 'hidden': return of(false);
+                }
+            }
+            // Check if there is anything to put in the filter menu.
+            return combineLatest([
+                this.exporters$.pipe(map(e => e.length > 0)),
+                this.filterMenuItems$.pipe(map(f => f.length > 0))
+            ]).pipe(map(v => v.indexOf(true) !== -1));
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this.options$ = this.def$.pipe(map(def => def ? def.options : undefined), shareReplay({ bufferSize: 1, refCount: true }));
+        this.menuBar$ = this.def$.pipe(map(def => (notNullOrUndefined(def) && hasProperty(def, 'menuBar')) ? def.menuBar : undefined), 
+        // tap(v => console.log('menubar', v)),
+        shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    /** Sets the `DatatableDynamicDef` that defines the datatable.  */
+    setDef(def) {
+        if (def) {
+            setDynamicDatatableDefDefaults(def);
+        }
+        this._defSubject.next(def || undefined);
+    }
+    /** Map the def exporters to the provided `IDataExporter` objects. */
+    _mapExporters(def) {
+        if (!def.filterMenu || !Array.isArray(def.filterMenu.exporters)) {
+            return [];
+        }
+        return def.filterMenu.exporters
+            .map(e => this._dataExporters.find(de => de.name === e))
+            .filter(notNullOrUndefined);
+    }
+    /** Map the def filter menu items to provided components. */
+    _mapFilterMenuItems(def) {
+        if (!def.filterMenu || !def.filterMenu.filters || !Array.isArray(def.filterMenu.filters)) {
+            return [];
+        }
+        return def.filterMenu.filters
+            .map(f => {
+            const _df = this._dataFilters.find(df => df.name === f.name);
+            if (_df) {
+                return { ...f, component: _df.component };
+            }
+        })
+            .filter(notNullOrUndefined);
+    }
+}
+DynamicDatatableDefService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicDatatableDefService, deps: [{ token: THESEAM_DATA_EXPORTER }, { token: THESEAM_DATA_FILTER_DEF }, { token: i1.DynamicValueHelperService }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicDatatableDefService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicDatatableDefService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicDatatableDefService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DATA_EXPORTER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER_DEF]
+                }] }, { type: i1.DynamicValueHelperService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-datatable-def.service.js","sourceRoot":"","sources":["../../../../projects/ui-common/datatable-dynamic/dynamic-datatable-def.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal'\nimport { Inject, Injectable } from '@angular/core'\nimport { BehaviorSubject, combineLatest, Observable, of } from 'rxjs'\nimport { map, shareReplay, switchMap } from 'rxjs/operators'\n\nimport { IDataExporter, THESEAM_DATA_EXPORTER } from '@theseam/ui-common/data-exporter'\nimport { IDataFilter, THESEAM_DATA_FILTER_DEF } from '@theseam/ui-common/data-filters'\nimport { DynamicValueHelperService } from '@theseam/ui-common/dynamic'\nimport { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { DynamicDatatableOptions } from './datatable-dynamic-def'\nimport { DatatableDynamicDef } from './datatable-dynamic-def'\nimport { DynamicDatatableMenuBar } from './models/dynamic-datatable-menu-bar'\nimport { DynamicDatatableFilterMenuItem } from './models/index'\nimport { setDynamicDatatableDefDefaults } from './utils/index'\n\n/**\n * Manages the data defined in the `DatatableDynamicDef`. Simplifies accessing\n * and observing the needed data based on the `DatatableDynamicDef`.\n */\n@Injectable()\nexport class DynamicDatatableDefService {\n\n  /**\n   * @deprecated\n   * @ignore\n   */\n  private _dataExporters: IDataExporter[]\n\n  /**\n   * @deprecated\n   * @ignore\n   */\n  private _dataFilters: { name: string, component: ComponentType<IDataFilter> }[]\n\n  /** @ignore */\n  private readonly _defSubject = new BehaviorSubject<DatatableDynamicDef | undefined>(undefined)\n\n  /** Dynamic datatable definition. */\n  public readonly def$: Observable<DatatableDynamicDef | undefined>\n\n  /**\n   * Exporters in the def that are available.\n   * @deprecated\n   */\n  public readonly exporters$: Observable<IDataExporter[]>\n\n  /**\n   * Filter menu items in the def that are available.\n   * @deprecated\n   */\n  public readonly filterMenuItems$: Observable<DynamicDatatableFilterMenuItem[]>\n\n  /**\n   * Observes whether the datatable has a filter menu.\n   * @deprecated\n   */\n  public readonly hasFilterMenu$: Observable<boolean>\n\n  /** Observes datatable options. */\n  public readonly options$: Observable<DynamicDatatableOptions | undefined>\n\n  /** Observes the datatable def menu bar. */\n  public readonly menuBar$: Observable<DynamicDatatableMenuBar | undefined>\n\n  constructor(\n    @Inject(THESEAM_DATA_EXPORTER) dataExporters: IDataExporter[],\n    @Inject(THESEAM_DATA_FILTER_DEF) dataFilters: { name: string, component: ComponentType<IDataFilter> }[],\n    private _valueHelper: DynamicValueHelperService,\n  ) {\n    this._dataExporters = (dataExporters || [])\n    this._dataFilters = (dataFilters || [])\n\n    this.def$ = this._defSubject.asObservable()\n\n    this.exporters$ = this.def$.pipe(\n      map(def => def ? this._mapExporters(def) : []),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.filterMenuItems$ = this.def$.pipe(\n      map(def => def ? this._mapFilterMenuItems(def) : []),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.hasFilterMenu$ = this.def$.pipe(\n      switchMap(def => {\n        if (!def) { return of(false) }\n\n        // Check if the visibility can be determined by the state value only.\n        if (def.filterMenu && def.filterMenu.state) {\n          switch (def.filterMenu.state) {\n            case 'always-visible': return of(true)\n            case 'hidden': return of(false)\n          }\n        }\n\n        // Check if there is anything to put in the filter menu.\n        return combineLatest([\n          this.exporters$.pipe(map(e => e.length > 0)),\n          this.filterMenuItems$.pipe(map(f => f.length > 0))\n        ]).pipe(map(v => v.indexOf(true) !== -1))\n      }),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.options$ = this.def$.pipe(\n      map(def => def ? def.options : undefined),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.menuBar$ = this.def$.pipe(\n      map(def => (notNullOrUndefined(def) && hasProperty(def, 'menuBar')) ? def.menuBar : undefined),\n      // tap(v => console.log('menubar', v)),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n  }\n\n  /** Sets the `DatatableDynamicDef` that defines the datatable.  */\n  public setDef(def: DatatableDynamicDef | undefined): void {\n    if (def) { setDynamicDatatableDefDefaults(def) }\n    this._defSubject.next(def || undefined)\n  }\n\n  /** Map the def exporters to the provided `IDataExporter` objects. */\n  private _mapExporters(def: DatatableDynamicDef): IDataExporter[] {\n    if (!def.filterMenu || !Array.isArray(def.filterMenu.exporters)) {\n      return []\n    }\n\n    return def.filterMenu.exporters\n      .map(e => this._dataExporters.find(de => de.name === e))\n      .filter(notNullOrUndefined)\n  }\n\n  /** Map the def filter menu items to provided components. */\n  private _mapFilterMenuItems(def: DatatableDynamicDef): DynamicDatatableFilterMenuItem[] {\n    if (!def.filterMenu || !def.filterMenu.filters || !Array.isArray(def.filterMenu.filters)) {\n      return []\n    }\n\n    return def.filterMenu.filters\n      .map(f => {\n        const _df = this._dataFilters.find(df => df.name === f.name)\n        if (_df) { return { ...f, component: _df.component } }\n      })\n      .filter(notNullOrUndefined)\n  }\n\n}\n"]}