@theseam/ui-common 0.3.11 → 0.4.0-beta.0

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

@@ -0,0 +1,63 @@
+import { Directive, EventEmitter, HostBinding, Input, Optional, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/modal";
+import * as i2 from "@theseam/ui-common/dynamic-component-loader";
+import * as i3 from "@angular/common/http";
+export class DatatableActionMenuItemDirective {
+    constructor(_modal, _dynamicComponentLoader, _http) {
+        this._modal = _modal;
+        this._dynamicComponentLoader = _dynamicComponentLoader;
+        this._http = _http;
+        this._listGroupItem = true;
+        this._listGroupItemAction = true;
+        this.click = new EventEmitter();
+    }
+    ngOnInit() { }
+    ngOnDestroy() { }
+}
+DatatableActionMenuItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableActionMenuItemDirective, deps: [{ token: i1.Modal }, { token: i2.TheSeamDynamicComponentLoader }, { token: i3.HttpClient, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableActionMenuItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: DatatableActionMenuItemDirective, selector: "[seamDatatableActionMenuItem]", inputs: { label: "label", href: ["attr.href", "href"], target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", routerLink: "routerLink", confirmDialog: "confirmDialog", row: "row" }, outputs: { click: "click" }, host: { properties: { "class.list-group-item": "this._listGroupItem", "class.list-group-item-action": "this._listGroupItemAction" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableActionMenuItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDatatableActionMenuItem]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Modal }, { type: i2.TheSeamDynamicComponentLoader }, { type: i3.HttpClient, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { _listGroupItem: [{
+                type: HostBinding,
+                args: ['class.list-group-item']
+            }], _listGroupItemAction: [{
+                type: HostBinding,
+                args: ['class.list-group-item-action']
+            }], label: [{
+                type: Input
+            }], href: [{
+                type: Input,
+                args: ['attr.href']
+            }], target: [{
+                type: Input
+            }], queryParams: [{
+                type: Input
+            }], fragment: [{
+                type: Input
+            }], queryParamsHandling: [{
+                type: Input
+            }], preserveFragment: [{
+                type: Input
+            }], skipLocationChange: [{
+                type: Input
+            }], replaceUrl: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], routerLink: [{
+                type: Input
+            }], confirmDialog: [{
+                type: Input
+            }], row: [{
+                type: Input
+            }], click: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-action-menu-item.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable/directives/datatable-action-menu-item.directive.ts"],"names":[],"mappings":"AAGA,OAAO,EAAa,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAgC,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;;;;;AAsCtI,MAAM,OAAO,gCAAgC;IAgE3C,YACmB,MAAa,EACb,uBAAsD,EAC1C,KAAiB;QAF7B,WAAM,GAAN,MAAM,CAAO;QACb,4BAAuB,GAAvB,uBAAuB,CAA+B;QAC1C,UAAK,GAAL,KAAK,CAAY;QAjEV,mBAAc,GAAG,IAAI,CAAA;QACd,yBAAoB,GAAG,IAAI,CAAA;QA2D9D,UAAK,GAAG,IAAI,YAAY,EAAO,CAAA;IAMrC,CAAC;IAEL,QAAQ,KAAK,CAAC;IAEd,WAAW,KAAK,CAAC;;6HAxEN,gCAAgC;iHAAhC,gCAAgC;2FAAhC,gCAAgC;kBAH5C,SAAS;mBAAC;oBACT,QAAQ,EAAE,+BAA+B;iBAC1C;;0BAoEI,QAAQ;4CAjE2B,cAAc;sBAAnD,WAAW;uBAAC,uBAAuB;gBACS,oBAAoB;sBAAhE,WAAW;uBAAC,8BAA8B;gBAElC,KAAK;sBAAb,KAAK;gBAGc,IAAI;sBAAvB,KAAK;uBAAC,WAAW;gBACT,MAAM;sBAAd,KAAK;gBAGG,WAAW;sBAAnB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBAEG,mBAAmB;sBAA3B,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBAEG,aAAa;sBAArB,KAAK;gBAsCG,GAAG;sBAAX,KAAK;gBAEI,KAAK;sBAAd,MAAM","sourcesContent":["// import { QueryParamsHandling } from '@angular/router/src/config'\nimport { ComponentType } from '@angular/cdk/portal'\nimport { HttpClient, HttpHeaders } from '@angular/common/http'\nimport { Component, Directive, EventEmitter, HostBinding, Input, isDevMode, OnDestroy, OnInit, Optional, Output } from '@angular/core'\nimport { Subscription } from 'rxjs'\n\n// import jexl from 'jexl'\n\nimport { TheSeamDynamicComponentLoader } from '@theseam/ui-common/dynamic-component-loader'\nimport { Modal } from '@theseam/ui-common/modal'\n\n//\n// TODO: Move the dynamic datatable logic out of this component when refactoring.\n//\n\n// export interface IActionMenuItemEndpointConfig {\n//   /**\n//    * Api endpoint.\n//    */\n//   endpoint?: string\n\n//   endpointExpr?: string\n\n//   method: 'GET' | 'POST' | 'PATCH' | 'DELETE'\n\n//   bodyExpr?: string\n\n//   paramsExpr?: string\n// }\n\n// export interface IActionMenuItemModalConfig {\n//   component: ComponentType<{}> |  string\n// }\n\nexport interface TheSeamDatatableRow {\n  [prop: string]: any\n}\n\n@Directive({\n  selector: '[seamDatatableActionMenuItem]'\n})\nexport class DatatableActionMenuItemDirective implements OnInit, OnDestroy {\n\n  @HostBinding('class.list-group-item') _listGroupItem = true\n  @HostBinding('class.list-group-item-action') _listGroupItemAction = true\n\n  @Input() label: string | undefined | null\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('attr.href') href: string | undefined | null\n  @Input() target: string | undefined | null\n\n  // Allow routerLink inputs on menu item\n  @Input() queryParams: { [k: string]: any } | undefined | null\n  @Input() fragment: string | undefined | null\n  // @Input() queryParamsHandling: QueryParamsHandling\n  @Input() queryParamsHandling: any | undefined | null\n  @Input() preserveFragment: boolean | undefined | null\n  @Input() skipLocationChange: boolean | undefined | null\n  @Input() replaceUrl: boolean | undefined | null\n  @Input() state: {[k: string]: any} | undefined | null\n  @Input() routerLink: string | any[] | undefined | null\n\n  @Input() confirmDialog: any\n\n  // @Input()\n  // get endpointConfig(): IActionMenuItemEndpointConfig { return this._endpointConfig }\n  // set endpointConfig(value: IActionMenuItemEndpointConfig) {\n  //   this._endpointConfig = value\n  //   if (value) {\n  //     // TODO: Handle this in a way that can be canceled.\n  //     this._endpointConfigSub = this.click\n  //       .pipe(untilDestroyed(this))\n  //       .subscribe(e => this._handleEndpointAction())\n  //   } else {\n  //     if (this._endpointConfigSub) {\n  //       this._endpointConfigSub.unsubscribe()\n  //     }\n  //   }\n  // }\n  // private _endpointConfig: IActionMenuItemEndpointConfig\n  // private _endpointConfigSub: Subscription\n\n  // @Input()\n  // get modalConfig(): IActionMenuItemModalConfig { return this._modalConfig }\n  // set modalConfig(value: IActionMenuItemModalConfig) {\n  //   this._modalConfig = value\n  //   if (value) {\n  //     // TODO: Handle this in a way that can be canceled.\n  //     this._modalConfigSub = this.click\n  //       .pipe(untilDestroyed(this))\n  //       .subscribe(e => this._handleModalAction())\n  //   } else {\n  //     if (this._modalConfigSub) {\n  //       this._modalConfigSub.unsubscribe()\n  //     }\n  //   }\n  // }\n  // private _modalConfig: IActionMenuItemModalConfig\n  // private _modalConfigSub: Subscription\n\n  @Input() row: TheSeamDatatableRow | undefined | null\n\n  @Output() click = new EventEmitter<any>()\n\n  constructor(\n    private readonly _modal: Modal,\n    private readonly _dynamicComponentLoader: TheSeamDynamicComponentLoader,\n    @Optional() private readonly _http: HttpClient,\n  ) { }\n\n  ngOnInit() { }\n\n  ngOnDestroy() { }\n\n  // private _handleEndpointAction() {\n  //   if (!this._http) {\n  //     if (isDevMode()) {\n  //       console.warn(`[DatatableActionMenuItemDirective] Endpoint actions require \\`HttpClientModule\\` to be imported.`)\n  //     }\n  //     return\n  //   }\n\n  //   // console.log('_handleEndpointAction')\n  //   // TODO: This should probably be done through a provider that uses the api.\n  //   if (isDevMode()) {\n  //     console.warn(`[DatatableActionMenuItemDirective] '_handleEndpointAction()' is not ready for production yet.`)\n  //   } else {\n  //     // I don't expect this to be attempted in prod before completed, so I am just adding a console warning.\n  //     console.warn(`Unable to complete request. Contact support for assistance.`)\n  //   }\n\n  //   let endpoint = ''\n  //   const method = this._endpointConfig.method\n  //   const context = { row: this.row }\n  //   // console.log('context', context)\n\n  //   if (this._endpointConfig.endpoint) {\n  //     endpoint = this._endpointConfig.endpoint\n  //   }\n\n  //   if (this._endpointConfig.endpointExpr) {\n  //     // TODO: Use async jexl.\n  //     endpoint = jexl.evalSync(this._endpointConfig.endpointExpr, context)\n  //   }\n\n  //   const url = `http://localhost:57648/api/${endpoint}`\n\n  //   const options: any = {}\n  //   if (this._endpointConfig.bodyExpr) {\n  //     // TODO: Use async jexl.\n  //     options.body = jexl.evalSync(this._endpointConfig.bodyExpr, context)\n  //   }\n  //   if (this._endpointConfig.paramsExpr) {\n  //     // TODO: Use async jexl.\n  //     options.params = jexl.evalSync(this._endpointConfig.paramsExpr, context)\n  //   }\n\n  //   const headers = new HttpHeaders({\n  //     'Content-Type': 'application/json'\n  //   })\n\n  //   this._http.request<any>(method, url, { ...options, headers })\n  //     .subscribe()\n  //     // .subscribe(v => console.log('v', v))\n  // }\n\n  // private _handleModalAction() {\n  //   if (typeof this._modalConfig.component === 'string') {\n  //     this._dynamicComponentLoader.getComponentFactory(this._modalConfig.component)\n  //       .subscribe(componentFactory => {\n  //         const factoryResolver = (<any /* ComponentFactoryBoundToModule */>componentFactory).ngModule.componentFactoryResolver\n  //         this._modal.openFromComponent(componentFactory.componentType, undefined, factoryResolver)\n  //       })\n  //   } else {\n  //     this._modal.openFromComponent(this._modalConfig.component)\n  //   }\n  // }\n\n}\n"]}

package/esm2020/datatable/directives/datatable-action-menu-toggle.directive.mjs

@@ -0,0 +1,137 @@
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class DatatableActionMenuToggleDirective {
+    constructor(_elementRef, _viewContainerRef, _overlay) {
+        this._elementRef = _elementRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._overlay = _overlay;
+        this._active = false;
+        this._actionDown = false;
+    }
+    _onKeydown(event) {
+        if (event.keyCode === ESCAPE) {
+            this.disable();
+        }
+    }
+    _onClick(event) {
+        this.toggle();
+    }
+    _mouseDown(event) { this.onInputDown(event); }
+    _pointerDown(event) { this.onInputDown(event); }
+    _mouseUp(event) { this.onInputUp(event); }
+    _pointerUp(event) { this.onInputUp(event); }
+    get active() { return this._active; }
+    toggle() {
+        if (this._active) {
+            this.disable();
+        }
+        else {
+            this.enable();
+        }
+    }
+    enable() {
+        if (this.active) {
+            return;
+        }
+        if (!this.seamDatatableActionMenuToggle) {
+            return;
+        }
+        this._overlayRef = this._overlay.create({
+            hasBackdrop: false,
+            positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),
+        });
+        this._overlayRef.attach(new TemplatePortal(this.seamDatatableActionMenuToggle, this._viewContainerRef));
+        this._active = true;
+    }
+    disable() {
+        if (!this.active) {
+            return;
+        }
+        if (this._overlayRef?.hasAttached()) {
+            this._overlayRef.detach();
+        }
+        this._active = false;
+    }
+    getOverlayPosition(origin) {
+        const positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(origin)
+            .withPositions(this.getPositions())
+            .withFlexibleDimensions(false)
+            .withPush(false);
+        return positionStrategy;
+    }
+    getPositions() {
+        return [
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+        ];
+    }
+    onFocusChangeOverlay(event) {
+        if (event === null) {
+            if (!this._actionDown) {
+                // this.disable()
+            }
+        }
+    }
+    onInputDown(event) {
+        this._actionDown = true;
+    }
+    onInputUp(event) {
+        this._actionDown = false;
+    }
+}
+DatatableActionMenuToggleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableActionMenuToggleDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.Overlay }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableActionMenuToggleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: DatatableActionMenuToggleDirective, selector: "[seamDatatableActionMenuToggle]", inputs: { seamDatatableActionMenuToggle: "seamDatatableActionMenuToggle" }, host: { listeners: { "document:keydown": "_onKeydown($event)", "click": "_onClick($event)", "mousedown": "_mouseDown($event)", "pointerdown": "_pointerDown($event)", "mouseup": "_mouseUp($event)", "pointerup": "_pointerUp($event)" } }, exportAs: ["seamDatatableActionMenuToggle"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableActionMenuToggleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDatatableActionMenuToggle]',
+                    exportAs: 'seamDatatableActionMenuToggle'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.Overlay }]; }, propDecorators: { seamDatatableActionMenuToggle: [{
+                type: Input
+            }], _onKeydown: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }], _onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], _mouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], _pointerDown: [{
+                type: HostListener,
+                args: ['pointerdown', ['$event']]
+            }], _mouseUp: [{
+                type: HostListener,
+                args: ['mouseup', ['$event']]
+            }], _pointerUp: [{
+                type: HostListener,
+                args: ['pointerup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-action-menu-toggle.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable/directives/datatable-action-menu-toggle.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ESCAPE } from '@angular/cdk/keycodes'\nimport { ConnectionPositionPair, Overlay, OverlayRef, PositionStrategy } from '@angular/cdk/overlay'\nimport { TemplatePortal } from '@angular/cdk/portal'\nimport { Directive, ElementRef, HostListener, Input, TemplateRef, ViewContainerRef } from '@angular/core'\n\n@Directive({\n  selector: '[seamDatatableActionMenuToggle]',\n  exportAs: 'seamDatatableActionMenuToggle'\n})\nexport class DatatableActionMenuToggleDirective {\n\n  @Input() seamDatatableActionMenuToggle: TemplateRef<HTMLElement> | undefined | null\n\n  private _active = false\n  private _overlayRef?: OverlayRef\n  private _actionDown = false\n\n  @HostListener('document:keydown', [ '$event' ])\n  _onKeydown(event: any) {\n    if (event.keyCode === ESCAPE) {\n      this.disable()\n    }\n  }\n\n  @HostListener('click', [ '$event' ])\n  _onClick(event: any) {\n    this.toggle()\n  }\n\n  @HostListener('mousedown', [ '$event' ]) _mouseDown(event: any) { this.onInputDown(event) }\n  @HostListener('pointerdown', [ '$event' ]) _pointerDown(event: any) { this.onInputDown(event) }\n\n  @HostListener('mouseup', [ '$event' ]) _mouseUp(event: any) { this.onInputUp(event) }\n  @HostListener('pointerup', [ '$event' ]) _pointerUp(event: any) { this.onInputUp(event) }\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _viewContainerRef: ViewContainerRef,\n    private _overlay: Overlay,\n  ) { }\n\n  public get active(): boolean { return this._active }\n\n  public toggle() {\n    if (this._active) {\n      this.disable()\n    } else {\n      this.enable()\n    }\n  }\n\n  public enable() {\n    if (this.active) { return }\n    if (!this.seamDatatableActionMenuToggle) { return }\n\n    this._overlayRef = this._overlay.create({\n      hasBackdrop: false,\n      positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),\n    })\n\n    this._overlayRef.attach(new TemplatePortal(this.seamDatatableActionMenuToggle, this._viewContainerRef))\n\n    this._active = true\n  }\n\n  public disable() {\n    if (!this.active) { return }\n\n    if (this._overlayRef?.hasAttached()) {\n      this._overlayRef.detach()\n    }\n\n    this._active = false\n  }\n\n  private getOverlayPosition(origin: HTMLElement): PositionStrategy {\n    const positionStrategy = this._overlay.position()\n      .flexibleConnectedTo(origin)\n      .withPositions(this.getPositions())\n      .withFlexibleDimensions(false)\n      .withPush(false)\n\n    return positionStrategy\n  }\n\n  private getPositions(): ConnectionPositionPair[] {\n    return [\n      {\n        originX: 'start',\n        originY: 'bottom',\n        overlayX: 'end',\n        overlayY: 'top',\n      },\n      {\n        originX: 'start',\n        originY: 'top',\n        overlayX: 'end',\n        overlayY: 'bottom',\n      },\n      {\n        originX: 'end',\n        originY: 'bottom',\n        overlayX: 'start',\n        overlayY: 'top',\n      },\n      {\n        originX: 'end',\n        originY: 'top',\n        overlayX: 'start',\n        overlayY: 'bottom',\n      },\n    ]\n  }\n\n  onFocusChangeOverlay(event: any) {\n    if (event === null) {\n      if (!this._actionDown) {\n        // this.disable()\n      }\n    }\n  }\n\n  onInputDown(event: any) {\n    this._actionDown = true\n  }\n\n  onInputUp(event: any) {\n    this._actionDown = false\n  }\n\n}\n"]}

package/esm2020/datatable/directives/datatable-cell-tpl.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DatatableCellTplDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+DatatableCellTplDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableCellTplDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableCellTplDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: DatatableCellTplDirective, selector: "[seamDatatableCellTpl]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableCellTplDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDatatableCellTpl]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLWNlbGwtdHBsLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9kYXRhdGFibGUvZGlyZWN0aXZlcy9kYXRhdGFibGUtY2VsbC10cGwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWUsTUFBTSxlQUFlLENBQUE7O0FBS3RELE1BQU0sT0FBTyx5QkFBeUI7SUFFcEMsWUFBbUIsUUFBMEI7UUFBMUIsYUFBUSxHQUFSLFFBQVEsQ0FBa0I7SUFBSSxDQUFDOztzSEFGdkMseUJBQXlCOzBHQUF6Qix5QkFBeUI7MkZBQXpCLHlCQUF5QjtrQkFIckMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsd0JBQXdCO2lCQUNuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VhbURhdGF0YWJsZUNlbGxUcGxdJ1xufSlcbmV4cG9ydCBjbGFzcyBEYXRhdGFibGVDZWxsVHBsRGlyZWN0aXZlIHtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHsgfVxuXG59XG4iXX0=

package/esm2020/datatable/directives/datatable-filter.directive.mjs

@@ -0,0 +1,27 @@
+import { Directive, Inject, Self } from '@angular/core';
+import { THESEAM_DATA_FILTER } from '@theseam/ui-common/data-filters';
+import * as i0 from "@angular/core";
+export class DatatableFilterDirective {
+    constructor(dataFilters) {
+        if (dataFilters && dataFilters.length > 0) {
+            this._filter = dataFilters[0];
+        }
+    }
+    get filter() {
+        return this._filter;
+    }
+}
+DatatableFilterDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableFilterDirective, deps: [{ token: THESEAM_DATA_FILTER, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableFilterDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: DatatableFilterDirective, selector: "[seamDatatableFilter]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableFilterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDatatableFilter]'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLWZpbHRlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZGF0YXRhYmxlL2RpcmVjdGl2ZXMvZGF0YXRhYmxlLWZpbHRlci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRXZELE9BQU8sRUFBZSxtQkFBbUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFBOztBQUtsRixNQUFNLE9BQU8sd0JBQXdCO0lBSW5DLFlBQ3VDLFdBQTBCO1FBRS9ELElBQUksV0FBVyxJQUFJLFdBQVcsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFO1lBQ3pDLElBQUksQ0FBQyxPQUFPLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFBO1NBQzlCO0lBQ0gsQ0FBQztJQUVELElBQUksTUFBTTtRQUNSLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUNyQixDQUFDOztxSEFkVSx3QkFBd0Isa0JBS2pCLG1CQUFtQjt5R0FMMUIsd0JBQXdCOzJGQUF4Qix3QkFBd0I7a0JBSHBDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHVCQUF1QjtpQkFDbEM7OzBCQU1JLElBQUk7OzBCQUFJLE1BQU07MkJBQUMsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbmplY3QsIFNlbGYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBJRGF0YUZpbHRlciwgVEhFU0VBTV9EQVRBX0ZJTFRFUiB9IGZyb20gJ0B0aGVzZWFtL3VpLWNvbW1vbi9kYXRhLWZpbHRlcnMnXG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tzZWFtRGF0YXRhYmxlRmlsdGVyXSdcbn0pXG5leHBvcnQgY2xhc3MgRGF0YXRhYmxlRmlsdGVyRGlyZWN0aXZlIHtcblxuICBwcml2YXRlIF9maWx0ZXI/OiBJRGF0YUZpbHRlclxuXG4gIGNvbnN0cnVjdG9yKFxuICAgIEBTZWxmKCkgQEluamVjdChUSEVTRUFNX0RBVEFfRklMVEVSKSBkYXRhRmlsdGVyczogSURhdGFGaWx0ZXJbXVxuICApIHtcbiAgICBpZiAoZGF0YUZpbHRlcnMgJiYgZGF0YUZpbHRlcnMubGVuZ3RoID4gMCkge1xuICAgICAgdGhpcy5fZmlsdGVyID0gZGF0YUZpbHRlcnNbMF1cbiAgICB9XG4gIH1cblxuICBnZXQgZmlsdGVyKCkge1xuICAgIHJldHVybiB0aGlzLl9maWx0ZXJcbiAgfVxuXG59XG4iXX0=

package/esm2020/datatable/directives/datatable-row-action-item.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DatatableRowActionItemDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+DatatableRowActionItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableRowActionItemDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableRowActionItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: DatatableRowActionItemDirective, selector: "[seamDatatableRowActionItem]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableRowActionItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDatatableRowActionItem]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLXJvdy1hY3Rpb24taXRlbS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZGF0YXRhYmxlL2RpcmVjdGl2ZXMvZGF0YXRhYmxlLXJvdy1hY3Rpb24taXRlbS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBZSxNQUFNLGVBQWUsQ0FBQTs7QUFLdEQsTUFBTSxPQUFPLCtCQUErQjtJQUUxQyxZQUFtQixRQUEwQjtRQUExQixhQUFRLEdBQVIsUUFBUSxDQUFrQjtJQUFJLENBQUM7OzRIQUZ2QywrQkFBK0I7Z0hBQS9CLCtCQUErQjsyRkFBL0IsK0JBQStCO2tCQUgzQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSw4QkFBOEI7aUJBQ3pDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tzZWFtRGF0YXRhYmxlUm93QWN0aW9uSXRlbV0nXG59KVxuZXhwb3J0IGNsYXNzIERhdGF0YWJsZVJvd0FjdGlvbkl0ZW1EaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PikgeyB9XG5cbn1cbiJdfQ==

package/esm2020/datatable/services/columns-alterations-manager.service.mjs

@@ -0,0 +1,136 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import { HideColumnColumnsAlteration } from '../models/columns-alterations/hide-column.columns-alteration';
+import { SortColumnsAlteration } from '../models/columns-alterations/sort.columns-alteration';
+import { WidthColumnsAlteration } from '../models/columns-alterations/width.columns-alteration';
+import * as i0 from "@angular/core";
+export class ColumnsAlterationsManagerService {
+    constructor() {
+        this._changesSubject = new Subject();
+        this._alterations = [];
+        this.changes = this._changesSubject.asObservable();
+    }
+    get() {
+        return [...this._alterations];
+    }
+    /**
+     * Adds alterations to be applied to columns.
+     *
+     * If an alteration with the same `id` already exists then the existing
+     * alteration will be removed and the new one added.
+     *
+     * NOTE: When there is a duplicate alteration the old alteration is removed,
+     * instead of updated, to maintain the order alterations are applied.
+     */
+    add(alterations, options) {
+        // console.log('add', alterations)
+        const removed = this.remove(alterations, { emitEvent: false });
+        this._alterations = [...this._alterations, ...alterations];
+        const changes = [
+            ...removed,
+            ...alterations.map(a => {
+                const record = {
+                    type: 'added',
+                    alteration: a
+                };
+                return record;
+            })
+        ];
+        if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {
+            return changes;
+        }
+        this._emitChanges(changes);
+        return changes;
+    }
+    remove(alterations, options) {
+        // console.log('remove', alterations)
+        const removed = [];
+        this._alterations = this._alterations.filter(x => {
+            const found = alterations.findIndex(y => y.id === x.id) !== -1;
+            if (found) {
+                const eventRecord = {
+                    type: 'removed',
+                    alteration: x
+                };
+                removed.push(eventRecord);
+            }
+            return !found;
+        });
+        // console.log('removed', removed, this._alterations)
+        if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {
+            return removed;
+        }
+        this._emitChanges(removed);
+        return removed;
+    }
+    apply(columns, datatable) {
+        for (const a of this._alterations) {
+            a.apply(columns, datatable);
+        }
+        this._removeNonPersistant();
+    }
+    // TODO: Make aware of original column order and properties. This is tricky,
+    // because the datatable does not deal with immutable column/row records and
+    // it is hard to know where changes happened. Just serializing the columns
+    // input is not enough, because the columns input is called anytime the user
+    // makes a column change. We can probably come up with a mostly accurate
+    // implementation, such as "reset original columns cache when preferencesKey
+    // changes" or "number of columns change". There are issues with those rules,
+    // but with some testing/experimenting I think there should be a "good enough"
+    // solution.
+    //
+    // TODO: Find a generic way to clear alterations. I would like to add an
+    // `unapply` method to `ColumnsAlteration`, but since the alterations
+    // themselves are not too generic it may be tricky.
+    clear(options) {
+        const changes = [];
+        for (const colAlt of this._alterations) {
+            switch (colAlt.type) {
+                case 'hide-column': {
+                    const alteration = new HideColumnColumnsAlteration({ columnProp: colAlt.state.columnProp, hidden: false }, false);
+                    changes.push(...this.add([alteration]));
+                    break;
+                }
+                case 'order': {
+                    changes.push(...this.remove([colAlt]));
+                    break;
+                }
+                case 'sort': {
+                    const alteration = new SortColumnsAlteration({ sorts: [] }, false);
+                    changes.push(...this.add([alteration]));
+                    break;
+                }
+                case 'width': {
+                    const alteration = new WidthColumnsAlteration({ columnProp: colAlt.state.columnProp, canAutoResize: true }, false);
+                    changes.push(...this.add([alteration]));
+                    break;
+                }
+            }
+        }
+        if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {
+            return changes;
+        }
+        this._emitChanges(changes);
+        return changes;
+    }
+    _removeNonPersistant() {
+        const nonPersistent = this._alterations.filter(x => !x.persistent);
+        this.remove(nonPersistent, { emitEvent: false });
+    }
+    _emitChanges(changes) {
+        if (changes.length === 0) {
+            return;
+        }
+        const event = {
+            changes
+        };
+        this._changesSubject.next(event);
+    }
+}
+ColumnsAlterationsManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ColumnsAlterationsManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ColumnsAlterationsManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ColumnsAlterationsManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ColumnsAlterationsManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns-alterations-manager.service.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable/services/columns-alterations-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { Observable, Subject } from 'rxjs'\n\nimport { notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { ColumnsAlteration } from '../models/columns-alteration'\nimport { TheSeamDatatableColumn } from '../models/table-column'\nimport { TheSeamDatatableAccessor } from '../models/datatable-accessor'\nimport { HideColumnColumnsAlteration } from '../models/columns-alterations/hide-column.columns-alteration'\nimport { SortColumnsAlteration } from '../models/columns-alterations/sort.columns-alteration'\nimport { WidthColumnsAlteration } from '../models/columns-alterations/width.columns-alteration'\n\nexport interface ColumnsAlterationsChangedRecord {\n  type: 'added' | 'removed'\n  alteration: ColumnsAlteration\n}\n\nexport interface ColumnsAlterationsChangedEvent {\n  changes: ColumnsAlterationsChangedRecord[]\n}\n\n@Injectable()\nexport class ColumnsAlterationsManagerService {\n\n  private readonly _changesSubject = new Subject<ColumnsAlterationsChangedEvent>()\n  private _alterations: ColumnsAlteration[] = []\n\n  public readonly changes: Observable<ColumnsAlterationsChangedEvent>\n\n  constructor() {\n    this.changes = this._changesSubject.asObservable()\n  }\n\n  public get(): ColumnsAlteration[] {\n    return [ ...this._alterations ]\n  }\n\n  /**\n   * Adds alterations to be applied to columns.\n   *\n   * If an alteration with the same `id` already exists then the existing\n   * alteration will be removed and the new one added.\n   *\n   * NOTE: When there is a duplicate alteration the old alteration is removed,\n   * instead of updated, to maintain the order alterations are applied.\n   */\n  public add(alterations: ColumnsAlteration[], options?: { emitEvent?: boolean }): ColumnsAlterationsChangedRecord[] {\n    // console.log('add', alterations)\n    const removed: ColumnsAlterationsChangedRecord[] = this.remove(alterations, { emitEvent: false })\n    this._alterations = [ ...this._alterations, ...alterations ]\n\n    const changes: ColumnsAlterationsChangedRecord[] = [\n      ...removed,\n      ...alterations.map(a => {\n        const record: ColumnsAlterationsChangedRecord = {\n          type: 'added',\n          alteration: a\n        }\n        return record\n      })\n    ]\n\n    if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {\n      return changes\n    }\n\n    this._emitChanges(changes)\n\n    return changes\n  }\n\n  public remove(alterations: ColumnsAlteration[], options?: { emitEvent?: boolean }): ColumnsAlterationsChangedRecord[] {\n    // console.log('remove', alterations)\n    const removed: ColumnsAlterationsChangedRecord[] = []\n    this._alterations = this._alterations.filter(x => {\n      const found = alterations.findIndex(y => y.id === x.id) !== -1\n      if (found) {\n        const eventRecord: ColumnsAlterationsChangedRecord = {\n          type: 'removed',\n          alteration: x\n        }\n        removed.push(eventRecord)\n      }\n      return !found\n    })\n\n    // console.log('removed', removed, this._alterations)\n\n    if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {\n      return removed\n    }\n\n    this._emitChanges(removed)\n\n    return removed\n  }\n\n  public apply(columns: TheSeamDatatableColumn[], datatable: TheSeamDatatableAccessor): void {\n    for (const a of this._alterations) {\n      a.apply(columns, datatable)\n    }\n\n    this._removeNonPersistant()\n  }\n\n  // TODO: Make aware of original column order and properties. This is tricky,\n  // because the datatable does not deal with immutable column/row records and\n  // it is hard to know where changes happened. Just serializing the columns\n  // input is not enough, because the columns input is called anytime the user\n  // makes a column change. We can probably come up with a mostly accurate\n  // implementation, such as \"reset original columns cache when preferencesKey\n  // changes\" or \"number of columns change\". There are issues with those rules,\n  // but with some testing/experimenting I think there should be a \"good enough\"\n  // solution.\n  //\n  // TODO: Find a generic way to clear alterations. I would like to add an\n  // `unapply` method to `ColumnsAlteration`, but since the alterations\n  // themselves are not too generic it may be tricky.\n  public clear(options?: { emitEvent?: boolean }): ColumnsAlterationsChangedRecord[] {\n    const changes: ColumnsAlterationsChangedRecord[] = []\n    for (const colAlt of this._alterations) {\n      switch (colAlt.type) {\n        case 'hide-column': {\n          const alteration = new HideColumnColumnsAlteration({ columnProp: colAlt.state.columnProp, hidden: false }, false)\n          changes.push(...this.add([ alteration ]))\n          break;\n        }\n        case 'order': {\n          changes.push(...this.remove([ colAlt ]))\n          break;\n        }\n        case 'sort': {\n          const alteration = new SortColumnsAlteration({ sorts: [] }, false)\n          changes.push(...this.add([ alteration ]))\n          break;\n        }\n        case 'width': {\n          const alteration = new WidthColumnsAlteration({ columnProp: colAlt.state.columnProp, canAutoResize: true }, false)\n          changes.push(...this.add([ alteration ]))\n          break;\n        }\n      }\n    }\n\n    if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {\n      return changes\n    }\n\n    this._emitChanges(changes)\n\n    return changes\n  }\n\n  private _removeNonPersistant(): void {\n    const nonPersistent = this._alterations.filter(x => !x.persistent)\n    this.remove(nonPersistent, { emitEvent: false })\n  }\n\n  private _emitChanges(changes: ColumnsAlterationsChangedRecord[]): void {\n    if (changes.length === 0) {\n      return\n    }\n\n    const event: ColumnsAlterationsChangedEvent = {\n      changes\n    }\n\n    this._changesSubject.next(event)\n  }\n\n}\n"]}