@theseam/ui-common 0.2.9

package/esm2015/datatable-dynamic/datatable-dynamic-def.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-dynamic-def.js","sourceRoot":"","sources":["../../../../projects/ui-common/datatable-dynamic/datatable-dynamic-def.ts"],"names":[],"mappings":"","sourcesContent":["import { PipeTransform } from '@angular/core'\nimport { TableColumnProp } from '@marklb/ngx-datatable'\n\nimport { TheSeamDatatableColumn, TheSeamDatatableRow } from '@theseam/ui-common/datatable'\n\nimport { DynamicValue } from '@theseam/ui-common/dynamic'\nimport { ThemeTypes } from '@theseam/ui-common/models'\nimport { TableCellTypeConfig, TableCellTypeName, TheSeamTableColumn } from '@theseam/ui-common/table-cell-type'\n\nimport { DynamicDatatableMenuBar } from './models/dynamic-datatable-menu-bar'\nimport { DynamicDatatableRowAction } from './models/dynamic-datatable-row-action'\n\nexport type DynamicDatatableColumn<T extends TableCellTypeName = any, C extends TableCellTypeConfig<T> = any> =\n  TheSeamDatatableColumn<T, C> | TheSeamTableColumn<T, C>\n\n// export interface DynamicDatatableColumn<T extends DynamicDatatableCellType, C extends DynamicDatatableCellTypeConfig<T>> {\n//   /**\n//    * Default: 'string'\n//    */\n//   cellType?: T\n//   /**\n//    * Config passed to the cell type component.\n//    */\n//   cellTypeConfig?: C\n//   /**\n//    * String to display if the exporter uses a header.\n//    */\n//   exportHeader?: string\n//   /**\n//    * Expression to calculate export value.\n//    * TODO: Implement. Jexl is most likely going to be used.\n//    * @deprecated\n//    */\n//   exportExpr?: string\n//   /**\n//    * Value or DynamicValue object to calculate export value.\n//    * TODO: Implement.\n//    */\n//   exportValue?: DynamicValue<string>\n\n//   /**\n//    * Determines if column is checkbox\n//    */\n//   checkboxable?: boolean\n//   /**\n//    * Determines if the column is frozen to the left\n//    */\n//   frozenLeft?: boolean\n//   /**\n//    * Determines if the column is frozen to the right\n//    */\n//   frozenRight?: boolean\n//   /**\n//    * The grow factor relative to other columns. Same as the flex-grow\n//    * API from http =//www.w3.org/TR/css3-flexbox/. Basically;\n//    * take any available extra width and distribute it proportionally\n//    * according to all columns' flexGrow values.\n//    */\n//   flexGrow?: number\n//   /**\n//    * Min width of the column\n//    */\n//   minWidth?: number\n//   /**\n//    * Max width of the column\n//    */\n//   maxWidth?: number\n//   /**\n//    * The default width of the column, in pixels\n//    */\n//   width?: number\n//   /**\n//    * Can the column be resized\n//    */\n//   resizeable?: boolean\n//   /**\n//    * Custom sort comparator\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   comparator?: any\n//   /**\n//    * Custom pipe transforms\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   pipe?: PipeTransform\n//   /**\n//    * Can the column be sorted\n//    */\n//   sortable?: boolean\n//   /**\n//    * Can the column be re-arranged by dragging\n//    */\n//   draggable?: boolean\n//   /**\n//    * Whether the column can automatically resize to fill space in the table.\n//    */\n//   canAutoResize?: boolean\n//   /**\n//    * Column name or label\n//    */\n//   name?: string\n//   /**\n//    * Property to bind to the row. Example:\n//    *\n//    * `someField` or `some.field.nested`, 0 (numeric)\n//    *\n//    * If left blank, will use the name as camel case conversion\n//    */\n//   prop?: TableColumnProp\n//   /**\n//    * Cell template ref\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   cellTemplate?: any\n//   /**\n//    * Header template ref\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   headerTemplate?: any\n//   /**\n//    * Tree toggle template ref\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   treeToggleTemplate?: any\n//   /**\n//    * CSS Classes for the cell\n//    *\n//    * NOTE: `Function` type not supported in JSON format\n//    */\n//   cellClass?: string | ((data: any) => string | any)\n//   /**\n//    * CSS classes for the header\n//    *\n//    *\n//    * NOTE: `Function` type not supported in JSON format\n//    */\n//   headerClass?: string | ((data: any) => string | any)\n//   /**\n//    * Header checkbox enabled\n//    */\n//   headerCheckboxable?: boolean\n//   /**\n//    * Is tree displayed on this column\n//    */\n//   isTreeColumn?: boolean\n//   /**\n//    * Width of the tree level indent\n//    */\n//   treeLevelIndent?: number\n//   /**\n//    * Summary function\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   summaryFunc?: (cells: any[]) => any\n//   /**\n//    * Summary cell template ref\n//    *\n//    * NOTE: Not supported in JSON format\n//    */\n//   summaryTemplate?: any\n// }\n\n// // export type DynamicDatatableColumnType =\n// //   DynamicDatatableColumn<'string', DynamicDatatableCellTypeConfigString> |\n// //   DynamicDatatableColumn<'integer', DynamicDatatableCellTypeConfigInteger> |\n// //   DynamicDatatableColumn<'decimal', DynamicDatatableCellTypeConfigDecimal> |\n// //   DynamicDatatableColumn<'date', DynamicDatatableCellTypeConfigDate> |\n// //   DynamicDatatableColumn<'icon', DynamicDatatableCellTypeConfigIcon>\n\nexport type DynamicDatatableRow = TheSeamDatatableRow\n\nexport interface DynamicDatatableFilterMenuItemDef<O = any> {\n\n  /** */\n  name: string\n\n  /**\n   * TODO: Refactor filter menu items to use locations instead of trying to\n   * maintain a mix of generic and specific types.\n   *\n   * Default: 'common'\n   */\n  type: 'common' | 'full-search'\n\n  /**\n   * Default: 0\n   */\n  order?: number\n\n  /** */\n  options?: O\n}\n\nexport interface DynamicDatatableFilterMenu {\n\n  /**\n   * Default 'default'\n   */\n  state?: 'hidden' | 'always-visible' | 'default'\n\n  /**\n   *\n   */\n  filters?: DynamicDatatableFilterMenuItemDef[]\n\n  /**\n   *\n   * Example: [ 'exporter:csv', 'exporter:xlsx' ]\n   */\n  exporters?: string[]\n\n}\n\nexport type DynamicDatatableFooterMenuItemType = 'button' | 'text'\n\nexport interface DynamicDatatableFooterMenuItem<T = DynamicDatatableFooterMenuItemType> {\n  type: T\n}\n\nexport interface DynamicDatatableFooterMenuItemButton extends DynamicDatatableFooterMenuItem<'button'> {\n  text: string\n  theme: ThemeTypes\n}\n\nexport interface DynamicDatatableFooterMenuItemText extends DynamicDatatableFooterMenuItem<'text'> {\n  text: string\n}\n\nexport interface DynamicDatatableOptions {\n  /**\n   * Default: false\n   */\n  virtualization?: boolean\n}\n\nexport interface DynamicDatatableFooterMenu {\n  /**\n   * Default 'default'\n   */\n  state?: 'hidden' | 'always-visible' | 'default'\n  items?: DynamicDatatableFooterMenuItem[]\n}\n\nexport interface DatatableDynamicDef {\n  readonly menuBar?: DynamicDatatableMenuBar\n  readonly filterMenu?: DynamicDatatableFilterMenu\n  readonly columns: DynamicDatatableColumn<TableCellTypeName, TableCellTypeConfig<TableCellTypeName>>[]\n  readonly rows: DynamicDatatableRow[]\n  readonly rowActions?: DynamicDatatableRowAction[]\n  // footerMenu?: DynamicDatatableFooterMenu\n  readonly options?: DynamicDatatableOptions\n}\n"]}

package/esm2015/datatable-dynamic/datatable-dynamic-filter-container/datatable-dynamic-filter-container.component.js

@@ -0,0 +1,53 @@
+import { ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, Injector, Input } from '@angular/core';
+import { THESEAM_DATA_FILTER_OPTIONS } from '@theseam/ui-common/data-filters';
+export class DatatableDynamicFilterContainerComponent {
+    constructor(_injector) {
+        this._injector = _injector;
+        this._portal = null;
+    }
+    set filterComponent(value) {
+        this._filterComponent = value;
+        // if (this._filterComponent !== value) {
+        //   this._setPortal(value)
+        // }
+    }
+    get filterComponent() { return this._filterComponent; }
+    ngOnInit() {
+        if (this.filterComponent) {
+            this._setPortal(this.filterComponent);
+        }
+    }
+    _setPortal(component) {
+        if (this._portal) {
+            this._portal = null;
+        }
+        if (component) {
+            this._portal = new ComponentPortal(component, undefined, this._createInjector());
+        }
+        else {
+            this._portal = null;
+        }
+    }
+    _createInjector() {
+        return new PortalInjector(this._injector, new WeakMap([
+            [THESEAM_DATA_FILTER_OPTIONS, this.options]
+        ]));
+    }
+}
+DatatableDynamicFilterContainerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-datatable-dynamic-filter-container',
+                template: "<ng-template [cdkPortalOutlet]=\"_portal\"></ng-template>\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{display:block}"]
+            },] }
+];
+DatatableDynamicFilterContainerComponent.ctorParameters = () => [
+    { type: Injector }
+];
+DatatableDynamicFilterContainerComponent.propDecorators = {
+    filterComponent: [{ type: Input }],
+    options: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datatable-dynamic/datatable-dynamic-menu-bar-content/datatable-dynamic-menu-bar-content.component.js

@@ -0,0 +1,160 @@
+import { __awaiter } from "tslib";
+import { ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, Inject, Injector, Input, Optional } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { DynamicValueHelperService } from '@theseam/ui-common/dynamic';
+import { TheSeamDynamicComponentLoader } from '@theseam/ui-common/dynamic-component-loader';
+import { hasProperty } from '@theseam/ui-common/utils';
+import { THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM } from '../datatable-dynamic-menu-bar-token';
+export class DatatableDynamicMenuBarContentComponent {
+    constructor(_valueHelper, _dynamicComponentLoader, _injector, _menuBarItemManifests) {
+        this._valueHelper = _valueHelper;
+        this._dynamicComponentLoader = _dynamicComponentLoader;
+        this._injector = _injector;
+        this._menuBarItemManifests = _menuBarItemManifests;
+        this._def = new BehaviorSubject(undefined);
+        this.def$ = this._def.asObservable();
+        // .pipe(tap(v => console.log('def$', v)))
+        this._rows$ = this.def$.pipe(switchMap(def => this._mapRows(def && def.rows || [])));
+        // .pipe(tap(v => console.log('_rows$', v)))
+    }
+    set def(value) { this._def.next(value); }
+    get def() { return this._def.value; }
+    ngOnInit() { }
+    _mapRows(rows) {
+        return Promise.all(rows.map(r => this._mapRow(r)));
+    }
+    _mapRow(row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const context = this._createRowContext(row);
+            if (hasProperty(row, 'styles')) {
+                result.styles = yield this._valueHelper.eval(row.styles, context);
+            }
+            if (hasProperty(row, 'cssClass')) {
+                result.cssClass = yield this._valueHelper.eval(row.cssClass, context);
+            }
+            if (hasProperty(row, 'priority')) {
+                result.priority = yield this._valueHelper.eval(row.priority, context);
+            }
+            result.layoutType = row.layout.type;
+            result.layout = yield this._mapRowLayout(row.layout, row);
+            return result;
+        });
+    }
+    _mapRowLayout(layout, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            if (hasProperty(layout, 'columnLeft')) {
+                result.columnLeft = yield this._mapColumn(layout.columnLeft, row);
+            }
+            if (hasProperty(layout, 'columnCenter')) {
+                result.columnCenter = yield this._mapColumn(layout.columnCenter, row);
+            }
+            if (hasProperty(layout, 'columnRight')) {
+                result.columnRight = yield this._mapColumn(layout.columnRight, row);
+            }
+            return result;
+        });
+    }
+    _mapColumn(column, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const context = this._createColumnContext(column, row);
+            if (hasProperty(column, 'styles')) {
+                result.styles = yield this._valueHelper.eval(column.styles, context);
+            }
+            if (hasProperty(column, 'cssClass')) {
+                result.cssClass = yield this._valueHelper.eval(column.cssClass, context);
+            }
+            result.items = yield Promise.all(column.items.map(v => this._mapItem(v, row, column)));
+            return result;
+        });
+    }
+    _mapItem(item, row, column) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const context = this._createItemContext(item, row, column);
+            // if (hasProperty(item, 'styles')) {
+            //   result.styles = await this._valueHelper.eval(item.styles, context)
+            // }
+            // if (hasProperty(item, 'cssClass')) {
+            //   result.cssClass = await this._valueHelper.eval(item.cssClass, context)
+            // }
+            if (hasProperty(item, 'component')) {
+                // result.component = await this._valueHelper.eval(item.component, context)
+                const component = yield this._valueHelper.eval(item.component, context);
+                let data;
+                if (hasProperty(item, 'data')) {
+                    // result.data = await this._valueHelper.eval(item.data, context)
+                    // console.log('%cdata', 'color:cyan', item.data)
+                    data = yield this._valueHelper.eval(item.data, context);
+                    // console.log('%cdata', 'color:limegreen', data)
+                }
+                result.portal = yield this._getComponentPortal(component, data);
+            }
+            return result;
+        });
+    }
+    _createRowContext(row) {
+        return {
+            row
+        };
+    }
+    _createColumnContext(column, row) {
+        return {
+            row,
+            column
+        };
+    }
+    _createItemContext(item, row, column) {
+        return {
+            item,
+            row,
+            column
+        };
+    }
+    _getComponentPortal(component, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manifest = (this._menuBarItemManifests || []).find(m => m.name === component);
+            if (!manifest) {
+                // TODO: Make sure the component is skipped instead of erroring outside of dev mode.
+                throw Error(`MenuBar manifest for '${component}' not found.`);
+            }
+            // TODO: Create a new injector with the data injected
+            let injector = this._injector;
+            if (manifest.dataToken) {
+                injector = new PortalInjector(this._injector, new WeakMap([
+                    [manifest.dataToken, data]
+                ]));
+            }
+            if (typeof manifest.component === 'string') {
+                this._dynamicComponentLoader.getComponentFactory(manifest.component).pipe(map(componentFactory => {
+                    return new ComponentPortal(componentFactory.componentType, null, injector, componentFactory.ngModule.componentFactoryResolver);
+                })).toPromise();
+            }
+            else {
+                return new ComponentPortal(manifest.component, null, injector, null);
+            }
+        });
+    }
+}
+DatatableDynamicMenuBarContentComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-datatable-dynamic-menu-bar-content',
+                template: "<seam-datatable-menu-bar-row *ngFor=\"let row of _rows$ | async; last as isLast\"\n  [class.mb-2]=\"!isLast\"\n  [ngClass]=\"$any(row.cssClass)\"\n  [ngStyle]=\"$any(row.styles)\">\n  <ng-container *ngIf=\"row.layoutType === 'tri-column'\">\n    <seam-datatable-menu-bar-column-left *ngIf=\"row.layout?.columnLeft\"\n      [ngClass]=\"$any(row.layout).cssClass\"\n      [ngStyle]=\"$any(row.layout).styles\">\n      <ng-container *ngIf=\"row.layout?.columnLeft?.items\">\n        <ng-container *ngFor=\"let item of row.layout?.columnLeft?.items\">\n          <ng-template [cdkPortalOutlet]=\"item.portal\"></ng-template>\n        </ng-container>\n      </ng-container>\n    </seam-datatable-menu-bar-column-left>\n    <seam-datatable-menu-bar-column-center *ngIf=\"row.layout?.columnCenter\"\n      [ngClass]=\"$any(row.layout).cssClass\"\n      [ngStyle]=\"$any(row.layout).styles\">\n      <ng-container *ngIf=\"row.layout?.columnCenter?.items\">\n        <ng-container *ngFor=\"let item of row.layout?.columnCenter?.items\">\n          <ng-template [cdkPortalOutlet]=\"item.portal\"></ng-template>\n        </ng-container>\n      </ng-container>\n    </seam-datatable-menu-bar-column-center>\n    <seam-datatable-menu-bar-column-right *ngIf=\"row.layout?.columnRight\"\n      [ngClass]=\"$any(row.layout).cssClass\"\n      [ngStyle]=\"$any(row.layout).styles\">\n      <ng-container *ngIf=\"row.layout?.columnRight?.items\">\n        <ng-container *ngFor=\"let item of row.layout?.columnRight?.items\">\n          <ng-template [cdkPortalOutlet]=\"item.portal\"></ng-template>\n        </ng-container>\n      </ng-container>\n    </seam-datatable-menu-bar-column-right>\n  </ng-container>\n</seam-datatable-menu-bar-row>\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+DatatableDynamicMenuBarContentComponent.ctorParameters = () => [
+    { type: DynamicValueHelperService },
+    { type: TheSeamDynamicComponentLoader },
+    { type: Injector },
+    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM,] }] }
+];
+DatatableDynamicMenuBarContentComponent.propDecorators = {
+    def: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-dynamic-menu-bar-content.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable-dynamic/datatable-dynamic-menu-bar-content/datatable-dynamic-menu-bar-content.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAU,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7G,OAAO,EAAE,eAAe,EAAc,MAAM,MAAM,CAAA;AAClD,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAA;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,6CAA6C,CAAA;AAC3F,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAGtD,OAAO,EAAE,sCAAsC,EAAE,MAAM,qCAAqC,CAAA;AA0D5F,MAAM,OAAO,uCAAuC;IAYlD,YACmB,YAAuC,EACvC,uBAAsD,EACtD,SAAmB,EAEnB,qBAA8D;QAJ9D,iBAAY,GAAZ,YAAY,CAA2B;QACvC,4BAAuB,GAAvB,uBAAuB,CAA+B;QACtD,cAAS,GAAT,SAAS,CAAU;QAEnB,0BAAqB,GAArB,qBAAqB,CAAyC;QAfhE,SAAI,GAAG,IAAI,eAAe,CAAsC,SAAS,CAAC,CAAA;QAiBzF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAA;QAClC,0CAA0C;QAE5C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;QAClF,4CAA4C;IAChD,CAAC;IApBD,IACI,GAAG,CAAC,KAA0C,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA,CAAC,CAAC;IAC7E,IAAI,GAAG,KAA0C,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAA,CAAC,CAAC;IAoBzE,QAAQ,KAAK,CAAC;IAEN,QAAQ,CAAC,IAAkC;QACjD,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACpD,CAAC;IAEa,OAAO,CAAC,GAA+B;;YACnD,MAAM,MAAM,GAAuC,EAAG,CAAA;YACtD,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAA;YAE3C,IAAI,WAAW,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE;gBAC9B,MAAM,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;aAClE;YAED,IAAI,WAAW,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE;gBAChC,MAAM,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;aACtE;YAED,IAAI,WAAW,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE;gBAChC,MAAM,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;aACtE;YAED,MAAM,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAA;YACnC,MAAM,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;YAEzD,OAAO,MAAM,CAAA;QACf,CAAC;KAAA;IAEa,aAAa,CACzB,MAAiD,EACjD,GAA+B;;YAE/B,MAAM,MAAM,GAAsD,EAAG,CAAA;YAErE,IAAI,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE;gBACrC,MAAM,CAAC,UAAU,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,CAAA;aAClE;YAED,IAAI,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,EAAE;gBACvC,MAAM,CAAC,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,YAAY,EAAE,GAAG,CAAC,CAAA;aACtE;YAED,IAAI,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAAE;gBACtC,MAAM,CAAC,WAAW,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAAA;aACpE;YAED,OAAO,MAAM,CAAA;QACf,CAAC;KAAA;IAEa,UAAU,CACtB,MAAqC,EACrC,GAA+B;;YAE/B,MAAM,MAAM,GAA0C,EAAG,CAAA;YACzD,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;YAEtD,IAAI,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;gBACjC,MAAM,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;aACrE;YAED,IAAI,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE;gBACnC,MAAM,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;aACzE;YAED,MAAM,CAAC,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;YAEtF,OAAO,MAAM,CAAA;QACf,CAAC;KAAA;IAEa,QAAQ,CACpB,IAAiC,EACjC,GAA+B,EAC/B,MAAqC;;YAErC,MAAM,MAAM,GAAwC,EAAG,CAAA;YACvD,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,CAAA;YAE1D,qCAAqC;YACrC,uEAAuE;YACvE,IAAI;YAEJ,uCAAuC;YACvC,2EAA2E;YAC3E,IAAI;YAEJ,IAAI,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE;gBAClC,2EAA2E;gBAC3E,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;gBAEvE,IAAI,IAAS,CAAA;gBACb,IAAI,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE;oBAC7B,iEAAiE;oBACjE,iDAAiD;oBACjD,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;oBACvD,iDAAiD;iBAClD;gBAED,MAAM,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;aAChE;YAED,OAAO,MAAM,CAAA;QACf,CAAC;KAAA;IAEO,iBAAiB,CAAC,GAA+B;QACvD,OAAO;YACL,GAAG;SACJ,CAAA;IACH,CAAC;IAEO,oBAAoB,CAC1B,MAAqC,EACrC,GAA+B;QAE/B,OAAO;YACL,GAAG;YACH,MAAM;SACP,CAAA;IACH,CAAC;IAEO,kBAAkB,CACxB,IAAiC,EACjC,GAA+B,EAC/B,MAAqC;QAErC,OAAO;YACL,IAAI;YACJ,GAAG;YACH,MAAM;SACP,CAAA;IACH,CAAC;IAEa,mBAAmB,CAAC,SAAiB,EAAE,IAAU;;YAC7D,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,qBAAqB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAA;YAEnF,IAAI,CAAC,QAAQ,EAAE;gBACb,oFAAoF;gBACpF,MAAM,KAAK,CAAC,yBAAyB,SAAS,cAAc,CAAC,CAAA;aAC9D;YAED,qDAAqD;YACrD,IAAI,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAA;YAC7B,IAAI,QAAQ,CAAC,SAAS,EAAE;gBACtB,QAAQ,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,OAAO,CAAC;oBACxD,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;iBAC3B,CAAC,CAAC,CAAA;aACJ;YAED,IAAI,OAAO,QAAQ,CAAC,SAAS,KAAK,QAAQ,EAAE;gBAC1C,IAAI,CAAC,uBAAuB,CAAC,mBAAmB,CAAK,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,CAC3E,GAAG,CAAC,gBAAgB,CAAC,EAAE;oBACrB,OAAO,IAAI,eAAe,CACxB,gBAAgB,CAAC,aAAa,EAC9B,IAAI,EACJ,QAAQ,EACkC,gBAAiB,CAAC,QAAQ,CAAC,wBAAwB,CAC9F,CAAA;gBACH,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAA;aACd;iBAAM;gBACL,OAAO,IAAI,eAAe,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;aACrE;QACH,CAAC;KAAA;;;YAjMF,SAAS,SAAC;gBACT,QAAQ,EAAE,yCAAyC;gBACnD,wsDAAkE;gBAElE,eAAe,EAAE,uBAAuB,CAAC,MAAM;;aAChD;;;YA9DQ,yBAAyB;YACzB,6BAA6B;YALe,QAAQ;wCAmFxD,QAAQ,YAAI,MAAM,SAAC,sCAAsC;;;kBAZ3D,KAAK","sourcesContent":["import { ComponentPortal, PortalInjector } from '@angular/cdk/portal'\nimport { ChangeDetectionStrategy, Component, Inject, Injector, Input, OnInit, Optional } from '@angular/core'\nimport { BehaviorSubject, Observable } from 'rxjs'\nimport { map, switchMap } from 'rxjs/operators'\n\nimport { DynamicValueHelperService } from '@theseam/ui-common/dynamic'\nimport { TheSeamDynamicComponentLoader } from '@theseam/ui-common/dynamic-component-loader'\nimport { hasProperty } from '@theseam/ui-common/utils'\n\nimport { IDatatableDynamicMenuBarItemManifest } from '../datatable-dynamic-menu-bar-item-manifest'\nimport { THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM } from '../datatable-dynamic-menu-bar-token'\nimport {\n  DynamicDatatableMenuBar,\n  DynamicDatatableMenuBarColumn,\n  DynamicDatatableMenuBarItem,\n  DynamicDatatableMenuBarRow,\n  DynamicDatatableMenuBarRowLayoutTriColumn\n} from '../models/dynamic-datatable-menu-bar'\n\nexport interface IDatatableDynamicMenuBarContentItem {\n  // styles?: string | string[]\n  // cssClass?: string | string[]\n  portal?: ComponentPortal<{}>\n  // component?: string | ComponentType<{}>\n  // config?: any\n}\n\nexport interface IDatatableDynamicMenuBarContentColumn {\n  styles?: string | string[]\n  cssClass?: string | string[]\n  items?: IDatatableDynamicMenuBarContentItem[]\n}\n\nexport interface IDatatableDynamicMenuBarContentRowLayoutTriColumn {\n  columnLeft?: IDatatableDynamicMenuBarContentColumn\n  columnCenter?: IDatatableDynamicMenuBarContentColumn\n  columnRight?: IDatatableDynamicMenuBarContentColumn\n}\n\nexport interface IDatatableDynamicMenuBarContentRow {\n  styles?: string | string[]\n  cssClass?: string | string[]\n  priority?: number\n  layoutType?: string\n  layout?: IDatatableDynamicMenuBarContentRowLayoutTriColumn\n}\n\nexport interface IDatatableDynamicMenuBarContentRowContext {\n  row: DynamicDatatableMenuBarRow\n}\n\nexport interface IDatatableDynamicMenuBarContentColumnContext {\n  column: DynamicDatatableMenuBarColumn\n  row: DynamicDatatableMenuBarRow\n}\n\nexport interface IDatatableDynamicMenuBarContentItemContext {\n  item: DynamicDatatableMenuBarItem\n  row: DynamicDatatableMenuBarRow\n  column: DynamicDatatableMenuBarColumn\n}\n\n@Component({\n  selector: 'seam-datatable-dynamic-menu-bar-content',\n  templateUrl: './datatable-dynamic-menu-bar-content.component.html',\n  styleUrls: ['./datatable-dynamic-menu-bar-content.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DatatableDynamicMenuBarContentComponent implements OnInit {\n\n  private readonly _def = new BehaviorSubject<DynamicDatatableMenuBar | undefined>(undefined)\n\n  @Input()\n  set def(value: DynamicDatatableMenuBar | undefined) { this._def.next(value) }\n  get def(): DynamicDatatableMenuBar | undefined { return this._def.value }\n\n  public readonly def$: Observable<DynamicDatatableMenuBar | undefined>\n\n  readonly _rows$: Observable<IDatatableDynamicMenuBarContentRow[]>\n\n  constructor(\n    private readonly _valueHelper: DynamicValueHelperService,\n    private readonly _dynamicComponentLoader: TheSeamDynamicComponentLoader,\n    private readonly _injector: Injector,\n    @Optional() @Inject(THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM)\n    private readonly _menuBarItemManifests?: IDatatableDynamicMenuBarItemManifest[]\n  ) {\n    this.def$ = this._def.asObservable()\n      // .pipe(tap(v => console.log('def$', v)))\n\n    this._rows$ = this.def$.pipe(switchMap(def => this._mapRows(def && def.rows || [])))\n      // .pipe(tap(v => console.log('_rows$', v)))\n  }\n\n  ngOnInit() { }\n\n  private _mapRows(rows: DynamicDatatableMenuBarRow[]): Promise<IDatatableDynamicMenuBarContentRow[]> {\n    return Promise.all(rows.map(r => this._mapRow(r)))\n  }\n\n  private async _mapRow(row: DynamicDatatableMenuBarRow): Promise<IDatatableDynamicMenuBarContentRow> {\n    const result: IDatatableDynamicMenuBarContentRow = { }\n    const context = this._createRowContext(row)\n\n    if (hasProperty(row, 'styles')) {\n      result.styles = await this._valueHelper.eval(row.styles, context)\n    }\n\n    if (hasProperty(row, 'cssClass')) {\n      result.cssClass = await this._valueHelper.eval(row.cssClass, context)\n    }\n\n    if (hasProperty(row, 'priority')) {\n      result.priority = await this._valueHelper.eval(row.priority, context)\n    }\n\n    result.layoutType = row.layout.type\n    result.layout = await this._mapRowLayout(row.layout, row)\n\n    return result\n  }\n\n  private async _mapRowLayout(\n    layout: DynamicDatatableMenuBarRowLayoutTriColumn,\n    row: DynamicDatatableMenuBarRow\n  ): Promise<IDatatableDynamicMenuBarContentRowLayoutTriColumn> {\n    const result: IDatatableDynamicMenuBarContentRowLayoutTriColumn = { }\n\n    if (hasProperty(layout, 'columnLeft')) {\n      result.columnLeft = await this._mapColumn(layout.columnLeft, row)\n    }\n\n    if (hasProperty(layout, 'columnCenter')) {\n      result.columnCenter = await this._mapColumn(layout.columnCenter, row)\n    }\n\n    if (hasProperty(layout, 'columnRight')) {\n      result.columnRight = await this._mapColumn(layout.columnRight, row)\n    }\n\n    return result\n  }\n\n  private async _mapColumn(\n    column: DynamicDatatableMenuBarColumn,\n    row: DynamicDatatableMenuBarRow\n  ): Promise<IDatatableDynamicMenuBarContentColumn> {\n    const result: IDatatableDynamicMenuBarContentColumn = { }\n    const context = this._createColumnContext(column, row)\n\n    if (hasProperty(column, 'styles')) {\n      result.styles = await this._valueHelper.eval(column.styles, context)\n    }\n\n    if (hasProperty(column, 'cssClass')) {\n      result.cssClass = await this._valueHelper.eval(column.cssClass, context)\n    }\n\n    result.items = await Promise.all(column.items.map(v => this._mapItem(v, row, column)))\n\n    return result\n  }\n\n  private async _mapItem(\n    item: DynamicDatatableMenuBarItem,\n    row: DynamicDatatableMenuBarRow,\n    column: DynamicDatatableMenuBarColumn\n  ): Promise<IDatatableDynamicMenuBarContentItem> {\n    const result: IDatatableDynamicMenuBarContentItem = { }\n    const context = this._createItemContext(item, row, column)\n\n    // if (hasProperty(item, 'styles')) {\n    //   result.styles = await this._valueHelper.eval(item.styles, context)\n    // }\n\n    // if (hasProperty(item, 'cssClass')) {\n    //   result.cssClass = await this._valueHelper.eval(item.cssClass, context)\n    // }\n\n    if (hasProperty(item, 'component')) {\n      // result.component = await this._valueHelper.eval(item.component, context)\n      const component = await this._valueHelper.eval(item.component, context)\n\n      let data: any\n      if (hasProperty(item, 'data')) {\n        // result.data = await this._valueHelper.eval(item.data, context)\n        // console.log('%cdata', 'color:cyan', item.data)\n        data = await this._valueHelper.eval(item.data, context)\n        // console.log('%cdata', 'color:limegreen', data)\n      }\n\n      result.portal = await this._getComponentPortal(component, data)\n    }\n\n    return result\n  }\n\n  private _createRowContext(row: DynamicDatatableMenuBarRow): IDatatableDynamicMenuBarContentRowContext {\n    return {\n      row\n    }\n  }\n\n  private _createColumnContext(\n    column: DynamicDatatableMenuBarColumn,\n    row: DynamicDatatableMenuBarRow\n  ): IDatatableDynamicMenuBarContentColumnContext {\n    return {\n      row,\n      column\n    }\n  }\n\n  private _createItemContext(\n    item: DynamicDatatableMenuBarItem,\n    row: DynamicDatatableMenuBarRow,\n    column: DynamicDatatableMenuBarColumn\n  ): IDatatableDynamicMenuBarContentItemContext {\n    return {\n      item,\n      row,\n      column\n    }\n  }\n\n  private async _getComponentPortal(component: string, data?: any): Promise<ComponentPortal<{}> | undefined> {\n    const manifest = (this._menuBarItemManifests || []).find(m => m.name === component)\n\n    if (!manifest) {\n      // TODO: Make sure the component is skipped instead of erroring outside of dev mode.\n      throw Error(`MenuBar manifest for '${component}' not found.`)\n    }\n\n    // TODO: Create a new injector with the data injected\n    let injector = this._injector\n    if (manifest.dataToken) {\n      injector = new PortalInjector(this._injector, new WeakMap([\n        [manifest.dataToken, data]\n      ]))\n    }\n\n    if (typeof manifest.component === 'string') {\n      this._dynamicComponentLoader.getComponentFactory<{}>(manifest.component).pipe(\n        map(componentFactory => {\n          return new ComponentPortal(\n            componentFactory.componentType,\n            null,\n            injector,\n            (<any /* ComponentFactoryBoundToModule */>componentFactory).ngModule.componentFactoryResolver\n          )\n        })\n      ).toPromise()\n    } else {\n      return new ComponentPortal(manifest.component, null, injector, null)\n    }\n  }\n\n}\n"]}

package/esm2015/datatable-dynamic/datatable-dynamic-menu-bar-item-manifest.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLWR5bmFtaWMtbWVudS1iYXItaXRlbS1tYW5pZmVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9kYXRhdGFibGUtZHluYW1pYy9kYXRhdGFibGUtZHluYW1pYy1tZW51LWJhci1pdGVtLW1hbmlmZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL3BvcnRhbCdcbmltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcblxuZXhwb3J0IGludGVyZmFjZSBJRGF0YXRhYmxlRHluYW1pY01lbnVCYXJJdGVtTWFuaWZlc3Q8VCA9IGFueT4ge1xuXG4gIC8qKlxuICAgKiBVbmlxdWUgbmFtZSB0byByZXByZXNlbnQgdGhpcyBpdGVtIGluIEpTT04gZGVmLlxuICAgKi9cbiAgbmFtZTogc3RyaW5nXG5cbiAgLyoqXG4gICAqIENvbXBvbmVudCB0byByZW5kZXIgZm9yIHRoaXMgaXRlbS5cbiAgICovXG4gIGNvbXBvbmVudDogQ29tcG9uZW50VHlwZTx7fT4gfCBzdHJpbmdcblxuICAvKipcbiAgICogSW5qZWN0aW9uVG9rZW4gdG8gaW5qZWN0IGRhdGEgYXMuXG4gICAqL1xuICBkYXRhVG9rZW4/OiBJbmplY3Rpb25Ub2tlbjxUPlxufVxuIl19

package/esm2015/datatable-dynamic/datatable-dynamic-menu-bar-token.js

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM = new InjectionToken('IDatatableDynamicMenuBarItemManifest');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLWR5bmFtaWMtbWVudS1iYXItdG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZGF0YXRhYmxlLWR5bmFtaWMvZGF0YXRhYmxlLWR5bmFtaWMtbWVudS1iYXItdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUk5QyxNQUFNLENBQUMsTUFBTSxzQ0FBc0MsR0FBRyxJQUFJLGNBQWMsQ0FDdEUsc0NBQXNDLENBQ3ZDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IElEYXRhdGFibGVEeW5hbWljTWVudUJhckl0ZW1NYW5pZmVzdCB9IGZyb20gJy4vZGF0YXRhYmxlLWR5bmFtaWMtbWVudS1iYXItaXRlbS1tYW5pZmVzdCdcblxuZXhwb3J0IGNvbnN0IFRIRVNFQU1fREFUQVRBQkxFX0RZTkFNSUNfTUVOVUJBUl9JVEVNID0gbmV3IEluamVjdGlvblRva2VuPElEYXRhdGFibGVEeW5hbWljTWVudUJhckl0ZW1NYW5pZmVzdD4oXG4gICdJRGF0YXRhYmxlRHluYW1pY01lbnVCYXJJdGVtTWFuaWZlc3QnXG4pXG4iXX0=

package/esm2015/datatable-dynamic/datatable-dynamic.component.js

@@ -0,0 +1,75 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { DynamicDatatableDefService } from './dynamic-datatable-def.service';
+import { DynamicDatatableRowActionsService } from './dynamic-datatable-row-actions.service';
+/**
+ * # EXPERIMENTAL
+ *
+ * NOTE: This component is still experimental. When stable all standard
+ * datatables must use this component, unless there is a good reason not to, in
+ * our apps.
+ *
+ * ----------------------------------------------------------------------------
+ *
+ * Datatable that is built from a json definition.
+ *
+ * All standard datatables in our apps must use this component, unless there is
+ * a good reason not to. If a standard datatable does not use this component
+ * then an explaination comment needs to be clearly provided in the code to
+ * avoid getting migrated to this component.
+ *
+ * A few reasons this component should to be used:
+ * - We can, more easily, control what a datatable in our app does by requiring
+ *   the definition follow a json schema, instead of having full scripting
+ *   access available to the developer.
+ *   + By using json we can maintain the tables from any external app/language
+ *     that can produce a json string.
+ *   + More scripting access often leads to different hacks across the tables
+ *     that should have just been supported by this component if it is a feature
+ *     a datatable should be able to do in an app of ours.
+ * - We can allow any of our tables to be configured by the server.
+ *   + By supporting configuration on the server we can change the tables
+ *     without a new build and do things like allowing non-developers/clients to
+ *     maintain the tables functionality.
+ */
+export class DatatableDynamicComponent {
+    constructor(_dynamicDef) {
+        this._dynamicDef = _dynamicDef;
+        this._hasDef$ = this._dynamicDef.def$.pipe(map(def => !!def));
+        this.menuBar$ = this._dynamicDef.menuBar$;
+        this._exporters$ = this._dynamicDef.exporters$;
+        this._commonFilterMenuItems$ = this._dynamicDef.filterMenuItems$
+            .pipe(map(f => f.filter(_f => _f.type === 'common')));
+        this._hasFullSearch$ = this._dynamicDef.filterMenuItems$
+            .pipe(map(f => !!f.find(_f => _f.type === 'full-search')));
+        this._hasFilterMenu$ = this._dynamicDef.hasFilterMenu$;
+        this._options$ = this._dynamicDef.options$;
+        this._tmp_columns$ = this._dynamicDef.def$.pipe(map(def => def ? def.columns : []));
+        this._tmp_rows$ = this._dynamicDef.def$.pipe(map(def => def ? def.rows : []));
+    }
+    /** The `DatatableDynamicDef` that defines the datatable. */
+    set def(value) {
+        this._dynamicDef.setDef(value || undefined);
+    }
+    /** @ignore */
+    ngOnInit() { }
+}
+DatatableDynamicComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-datatable-dynamic',
+                template: "<ng-container *ngIf=\"_hasDef$ | async\">\n  <seam-datatable *ngIf=\"_options$ | async as opts\"\n    class=\"w-100 h-100\"\n    [columns]=\"_tmp_columns$ | async\"\n    [rows]=\"_tmp_rows$ | async\"\n    [virtualization]=\"opts.virtualization\">\n\n    <seam-datatable-menu-bar *ngIf=\"menuBar$ | async as menuBar\">\n      <seam-datatable-dynamic-menu-bar-content [def]=\"menuBar\"></seam-datatable-dynamic-menu-bar-content>\n    </seam-datatable-menu-bar>\n    <!-- <seam-datatable-menu-bar *ngIf=\"_hasFilterMenu$ | async\">\n      <div class=\"d-flex flex-row pb-2\">\n        <div class=\"d-flex flex-row justify-content-end flex-grow-1\">\n          <seam-data-filter-search seamDatatableFilter *ngIf=\"_hasFullSearch$\"></seam-data-filter-search>\n        </div>\n      </div>\n      <div class=\"d-flex flex-row\">\n        <div class=\"d-flex justify-content-center flex-grow-1\">\n          <ng-container *ngFor=\"let r of _commonFilterMenuItems$ | async; let isFirst = first\">\n            <seam-datatable-dynamic-filter-container\n              [class.ml-1]=\"!isFirst\"\n              [filterComponent]=\"r.component\"\n              [options]=\"r.options\">\n            </seam-datatable-dynamic-filter-container>\n          </ng-container>\n        </div>\n        <seam-datatable-export-button *ngIf=\"_exporters$ | async as exporters\"\n          [exporters]=\"exporters\">\n        </seam-datatable-export-button>\n      </div>\n    </seam-datatable-menu-bar> -->\n\n    <ng-template seamDatatableRowActionItem let-row>\n      <seam-datatable-dynamic-action-menu [row]=\"row\"></seam-datatable-dynamic-action-menu>\n    </ng-template>\n\n  </seam-datatable>\n</ng-container>\n",
+                providers: [
+                    DynamicDatatableDefService,
+                    DynamicDatatableRowActionsService
+                ],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{display:flex;flex-direction:column}"]
+            },] }
+];
+DatatableDynamicComponent.ctorParameters = () => [
+    { type: DynamicDatatableDefService }
+];
+DatatableDynamicComponent.propDecorators = {
+    def: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-dynamic.component.js","sourceRoot":"","sources":["../../../../projects/ui-common/datatable-dynamic/datatable-dynamic.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAAU,MAAM,eAAe,CAAA;AAEjF,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAQpC,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA;AAC5E,OAAO,EAAE,iCAAiC,EAAE,MAAM,yCAAyC,CAAA;AAI3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAWH,MAAM,OAAO,yBAAyB;IA4DpC,YACmB,WAAuC;QAAvC,gBAAW,GAAX,WAAW,CAA4B;QAExD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;QAE7D,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAA;QAEzC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAA;QAE9C,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,WAAW,CAAC,gBAAgB;aAC7D,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAA;QAEvD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,gBAAgB;aACrD,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC,CAAC,CAAA;QAE5D,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,cAAc,CAAA;QAEtD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAA;QAE1C,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAC7C,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CACnC,CAAA;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAC1C,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAEhC,CAAA;IACH,CAAC;IArFD,4DAA4D;IAC5D,IAAa,GAAG,CAAC,KAA6C;QAC5D,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,IAAI,SAAS,CAAC,CAAA;IAC7C,CAAC;IAoFD,cAAc;IACd,QAAQ,KAAK,CAAC;;;YApGf,SAAS,SAAC;gBACT,QAAQ,EAAE,wBAAwB;gBAClC,4qDAAiD;gBAEjD,SAAS,EAAE;oBACT,0BAA0B;oBAC1B,iCAAiC;iBAClC;gBACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;;aAChD;;;YA5CQ,0BAA0B;;;kBAgDhC,KAAK","sourcesContent":["import { ChangeDetectionStrategy, Component, Input, OnInit } from '@angular/core'\nimport { Observable } from 'rxjs'\nimport { map } from 'rxjs/operators'\n\nimport { IDataExporter } from '@theseam/ui-common/data-exporter'\n\nimport {\n  DatatableDynamicDef,\n  DynamicDatatableOptions\n} from './datatable-dynamic-def'\nimport { DynamicDatatableDefService } from './dynamic-datatable-def.service'\nimport { DynamicDatatableRowActionsService } from './dynamic-datatable-row-actions.service'\nimport { DynamicDatatableFilterMenuItem } from './models/dynamic-datatable-filter-menu-item'\nimport { DynamicDatatableMenuBar } from './models/dynamic-datatable-menu-bar'\n\n/**\n * # EXPERIMENTAL\n *\n * NOTE: This component is still experimental. When stable all standard\n * datatables must use this component, unless there is a good reason not to, in\n * our apps.\n *\n * ----------------------------------------------------------------------------\n *\n * Datatable that is built from a json definition.\n *\n * All standard datatables in our apps must use this component, unless there is\n * a good reason not to. If a standard datatable does not use this component\n * then an explaination comment needs to be clearly provided in the code to\n * avoid getting migrated to this component.\n *\n * A few reasons this component should to be used:\n * - We can, more easily, control what a datatable in our app does by requiring\n *   the definition follow a json schema, instead of having full scripting\n *   access available to the developer.\n *   + By using json we can maintain the tables from any external app/language\n *     that can produce a json string.\n *   + More scripting access often leads to different hacks across the tables\n *     that should have just been supported by this component if it is a feature\n *     a datatable should be able to do in an app of ours.\n * - We can allow any of our tables to be configured by the server.\n *   + By supporting configuration on the server we can change the tables\n *     without a new build and do things like allowing non-developers/clients to\n *     maintain the tables functionality.\n */\n@Component({\n  selector: 'seam-datatable-dynamic',\n  templateUrl: './datatable-dynamic.component.html',\n  styleUrls: ['./datatable-dynamic.component.scss'],\n  providers: [\n    DynamicDatatableDefService,\n    DynamicDatatableRowActionsService\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DatatableDynamicComponent implements OnInit {\n\n  /** The `DatatableDynamicDef` that defines the datatable. */\n  @Input() set def(value: DatatableDynamicDef | undefined | null) {\n    this._dynamicDef.setDef(value || undefined)\n  }\n\n  /**\n   * Observes whether the datatable has a def.\n   * @ignore\n   */\n  _hasDef$: Observable<boolean>\n\n  /**\n   * Observes whether the datatable has a menu bar.\n   */\n  menuBar$: Observable<DynamicDatatableMenuBar  | undefined>\n\n  /**\n   * The available exporters.\n   * @ignore\n   */\n  _exporters$: Observable<IDataExporter[]>\n\n  /**\n   * The 'common' type filter menu items.\n   * @ignore\n   */\n  _commonFilterMenuItems$: Observable<DynamicDatatableFilterMenuItem[]>\n\n  /**\n   * Observes whether the datatable has a 'full-search' menu item.\n   * @ignore\n   */\n  _hasFullSearch$: Observable<boolean>\n\n  /**\n   * Observes whether the datatable has a filter menu.\n   * @ignore\n   */\n  _hasFilterMenu$: Observable<boolean>\n\n  /**\n   * Observes datatable options.\n   * @ignore\n   */\n  _options$: Observable<DynamicDatatableOptions | undefined>\n\n  /**\n   * TODO: Implement def columns parser.\n   * @ignore\n   */\n  _tmp_columns$: Observable<any>\n\n  /**\n   * TODO: Implement def rows parser.\n   * @ignore\n   */\n  _tmp_rows$: Observable<any>\n\n  constructor(\n    private readonly _dynamicDef: DynamicDatatableDefService\n  ) {\n    this._hasDef$ = this._dynamicDef.def$.pipe(map(def => !!def))\n\n    this.menuBar$ = this._dynamicDef.menuBar$\n\n    this._exporters$ = this._dynamicDef.exporters$\n\n    this._commonFilterMenuItems$ = this._dynamicDef.filterMenuItems$\n      .pipe(map(f => f.filter(_f => _f.type === 'common')))\n\n    this._hasFullSearch$ = this._dynamicDef.filterMenuItems$\n      .pipe(map(f => !!f.find(_f => _f.type === 'full-search')))\n\n    this._hasFilterMenu$ = this._dynamicDef.hasFilterMenu$\n\n    this._options$ = this._dynamicDef.options$\n\n    this._tmp_columns$ = this._dynamicDef.def$.pipe(\n      map(def => def ? def.columns : [])\n    )\n\n    this._tmp_rows$ = this._dynamicDef.def$.pipe(\n      map(def => def ? def.rows : []),\n      // tap(v => console.log('_tmp_rows$', v))\n    )\n  }\n\n  /** @ignore */\n  ngOnInit() { }\n\n}\n"]}

package/esm2015/datatable-dynamic/datatable-dynamic.module.js

@@ -0,0 +1,49 @@
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { TheSeamButtonsModule } from '@theseam/ui-common/buttons';
+import { TheSeamDataExporterModule } from '@theseam/ui-common/data-exporter';
+import { TheSeamDataFiltersModule } from '@theseam/ui-common/data-filters';
+import { TheSeamDatatableModule } from '@theseam/ui-common/datatable';
+import { TheSeamIconModule } from '@theseam/ui-common/icon';
+import { TheSeamMenuModule } from '@theseam/ui-common/menu';
+import { TheSeamSharedModule } from '@theseam/ui-common/shared';
+import { TheSeamTableCellTypesModule } from '@theseam/ui-common/table-cell-types';
+import { DatatableDynamicActionMenuComponent } from './datatable-dynamic-action-menu/datatable-dynamic-action-menu.component';
+import { DatatableDynamicFilterContainerComponent } from './datatable-dynamic-filter-container/datatable-dynamic-filter-container.component';
+import { DatatableDynamicMenuBarContentComponent } from './datatable-dynamic-menu-bar-content/datatable-dynamic-menu-bar-content.component';
+import { DatatableDynamicComponent } from './datatable-dynamic.component';
+import { DatatableDynamicActionMenuItemDirective } from './directives/datatable-dynamic-action-menu-item.directive';
+export class TheSeamDatatableDynamicModule {
+}
+TheSeamDatatableDynamicModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    DatatableDynamicComponent,
+                    DatatableDynamicFilterContainerComponent,
+                    DatatableDynamicActionMenuComponent,
+                    DatatableDynamicActionMenuItemDirective,
+                    DatatableDynamicMenuBarContentComponent,
+                ],
+                imports: [
+                    CommonModule,
+                    TheSeamSharedModule,
+                    TheSeamDatatableModule,
+                    TheSeamTableCellTypesModule,
+                    TheSeamDataExporterModule,
+                    TheSeamDataFiltersModule,
+                    TheSeamIconModule,
+                    PortalModule,
+                    RouterModule,
+                    TheSeamMenuModule,
+                    TheSeamButtonsModule
+                ],
+                exports: [
+                    DatatableDynamicComponent,
+                    TheSeamDatatableModule,
+                    DatatableDynamicActionMenuItemDirective
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datatable-dynamic/directives/datatable-dynamic-action-menu-item.directive.js

@@ -0,0 +1,408 @@
+import { LocationStrategy } from '@angular/common';
+import { Attribute, Directive, ElementRef, Input, isDevMode, Renderer2 } from '@angular/core';
+import { ActivatedRoute, Router, RouterLink, RouterLinkWithHref } from '@angular/router';
+import { from, fromEvent, of, ReplaySubject, Subscription } from 'rxjs';
+import { catchError, mapTo, switchMap, tap } from 'rxjs/operators';
+import { AssetReaderHelperService } from '@theseam/ui-common/asset-reader';
+import { DynamicActionHelperService, DynamicValueHelperService } from '@theseam/ui-common/dynamic';
+import { getAttribute, hasProperty, toggleAttribute } from '@theseam/ui-common/utils';
+/**
+ * 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`.
+ */
+export 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, 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.ctorParameters = () => [
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] },
+    { type: Renderer2 },
+    { type: ElementRef },
+    { type: LocationStrategy }
+];
+// TODO: Refactor this directive. It got way more complex instead of more
+// simplified like it was supposed to be.
+export class DatatableDynamicActionMenuItemDirective {
+    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 => {
+            if (isDevMode()) {
+                console.error(error);
+            }
+            this._setInvalidActionState(true);
+            return of(undefined);
+        })).subscribe();
+    }
+    set seamDatatableDynamicActionMenuItem(value) {
+        this._record.next(value);
+    }
+    ngOnInit() { }
+    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 = Object.assign(Object.assign({}, _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 = Object.assign(Object.assign({}, _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.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamDatatableDynamicActionMenuItem]',
+                exportAs: 'seamDatatableDynamicActionMenuItem'
+            },] }
+];
+DatatableDynamicActionMenuItemDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: DynamicValueHelperService },
+    { type: DynamicActionHelperService },
+    { type: AssetReaderHelperService },
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: LocationStrategy }
+];
+DatatableDynamicActionMenuItemDirective.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  OnInit,\n  Renderer2\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        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.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 OnInit, 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        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  ngOnInit() { }\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: {}) {\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"]}