@colijnit/corecomponents_v12 12.2.21 → 12.2.23

package/esm2015/lib/components/popup/text-input-popup.component.js

@@ -0,0 +1,36 @@
+import { __awaiter } from "tslib";
+import { ChangeDetectorRef, Component, Input } from '@angular/core';
+// A popup component that lets the user type and submit a text string.
+export class TextInputPopupComponent {
+    constructor(_changeDetector) {
+        this._changeDetector = _changeDetector;
+    }
+    ngOnDestroy() {
+        this._changeDetector = undefined;
+    }
+    ngAfterViewInit() {
+        this._changeDetector.detectChanges(); // fixes some changed-after-checked bug (popup service could have manipulated our text and label @Input's ..)
+    }
+    // @implements AppPopup
+    onClose(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.text;
+        });
+    }
+}
+TextInputPopupComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-text-input-popup",
+                template: `
+        <co-input-text [(model)]="text" [label]="label" [noValidation]="true" [initFocus]="true"></co-input-text>
+    `
+            },] }
+];
+TextInputPopupComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+TextInputPopupComponent.propDecorators = {
+    text: [{ type: Input }],
+    label: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/responsive-text/responsive-text.component.js

@@ -0,0 +1,24 @@
+import { Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+export class ResponsiveTextComponent {
+    showClass() {
+        return true;
+    }
+}
+ResponsiveTextComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-responsive-text',
+                template: `
+        <svg viewBox="0 0 100 100">
+            <foreignObject height="100%" width="100%">
+                <div class="text" [textContent]="text"></div>
+            </foreignObject>            
+        </svg>
+    `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+ResponsiveTextComponent.propDecorators = {
+    text: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ['class.co-responsive-text',] }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzcG9uc2l2ZS10ZXh0LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9yZXNwb25zaXZlLXRleHQvcmVzcG9uc2l2ZS10ZXh0LmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsaUJBQWlCLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFhL0UsTUFBTSxPQUFPLHVCQUF1QjtJQU16QixTQUFTO1FBQ1osT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQzs7O1lBbkJKLFNBQVMsU0FBQztnQkFDUCxRQUFRLEVBQUUsb0JBQW9CO2dCQUM5QixRQUFRLEVBQUU7Ozs7OztLQU1UO2dCQUNELGFBQWEsRUFBRSxpQkFBaUIsQ0FBQyxJQUFJO2FBQ3hDOzs7bUJBR0ksS0FBSzt3QkFHTCxXQUFXLFNBQUMsMEJBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21wb25lbnQsIEhvc3RCaW5kaW5nLCBJbnB1dCwgVmlld0VuY2Fwc3VsYXRpb259IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgICBzZWxlY3RvcjogJ2NvLXJlc3BvbnNpdmUtdGV4dCcsXHJcbiAgICB0ZW1wbGF0ZTogYFxyXG4gICAgICAgIDxzdmcgdmlld0JveD1cIjAgMCAxMDAgMTAwXCI+XHJcbiAgICAgICAgICAgIDxmb3JlaWduT2JqZWN0IGhlaWdodD1cIjEwMCVcIiB3aWR0aD1cIjEwMCVcIj5cclxuICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJ0ZXh0XCIgW3RleHRDb250ZW50XT1cInRleHRcIj48L2Rpdj5cclxuICAgICAgICAgICAgPC9mb3JlaWduT2JqZWN0PiAgICAgICAgICAgIFxyXG4gICAgICAgIDwvc3ZnPlxyXG4gICAgYCxcclxuICAgIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmVcclxufSlcclxuZXhwb3J0IGNsYXNzIFJlc3BvbnNpdmVUZXh0Q29tcG9uZW50IHtcclxuXHJcbiAgICBASW5wdXQoKVxyXG4gICAgcHVibGljIHRleHQ6IHN0cmluZztcclxuXHJcbiAgICBASG9zdEJpbmRpbmcoJ2NsYXNzLmNvLXJlc3BvbnNpdmUtdGV4dCcpXHJcbiAgICBwdWJsaWMgc2hvd0NsYXNzKCkge1xyXG4gICAgICAgIHJldHVybiB0cnVlO1xyXG4gICAgfVxyXG5cclxufSBcclxuIl19

package/esm2015/lib/components/responsive-text/responsive-text.module.js

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ResponsiveTextComponent } from './responsive-text.component';
+export class ResponsiveTextModule {
+}
+ResponsiveTextModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule
+                ],
+                declarations: [
+                    ResponsiveTextComponent
+                ],
+                exports: [
+                    ResponsiveTextComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzcG9uc2l2ZS10ZXh0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9yZXNwb25zaXZlLXRleHQvcmVzcG9uc2l2ZS10ZXh0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsdUJBQXVCLEVBQUMsTUFBTSw2QkFBNkIsQ0FBQztBQWFwRSxNQUFNLE9BQU8sb0JBQW9COzs7WUFYaEMsUUFBUSxTQUFDO2dCQUNOLE9BQU8sRUFBRTtvQkFDTCxZQUFZO2lCQUNmO2dCQUNELFlBQVksRUFBRTtvQkFDVix1QkFBdUI7aUJBQzFCO2dCQUNELE9BQU8sRUFBRTtvQkFDTCx1QkFBdUI7aUJBQzFCO2FBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7UmVzcG9uc2l2ZVRleHRDb21wb25lbnR9IGZyb20gJy4vcmVzcG9uc2l2ZS10ZXh0LmNvbXBvbmVudCc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gICAgaW1wb3J0czogW1xyXG4gICAgICAgIENvbW1vbk1vZHVsZVxyXG4gICAgXSxcclxuICAgIGRlY2xhcmF0aW9uczogW1xyXG4gICAgICAgIFJlc3BvbnNpdmVUZXh0Q29tcG9uZW50XHJcbiAgICBdLFxyXG4gICAgZXhwb3J0czogW1xyXG4gICAgICAgIFJlc3BvbnNpdmVUZXh0Q29tcG9uZW50XHJcbiAgICBdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBSZXNwb25zaXZlVGV4dE1vZHVsZSB7XHJcbn1cclxuIl19

package/esm2015/lib/components/simple-grid/base-simple-grid.component.js

@@ -0,0 +1,164 @@
+import { ContentChildren, Directive, EventEmitter, HostListener, Input, Output } from "@angular/core";
+import { SimpleGridColumnDirective } from "./simple-grid-column.directive";
+import { moveItemInArray } from "@angular/cdk/drag-drop";
+import { Subject } from "rxjs";
+export class BaseSimpleGridComponent {
+    constructor() {
+        this.MIN_COLUMN_WIDTH = 50;
+        this.dataChanged = new Subject();
+        this.dragDropEnabled = false;
+        this.resizable = false;
+        this.inlineEdit = false;
+        this.showEdit = false;
+        this.showToolbar = false;
+        this.autoAddRow = false;
+        /**
+         * Should component emit drag and drop actions instead of handle
+         * (update collection) by itself
+         */
+        this.emitDragDrop = false;
+        this.onDrop = new EventEmitter();
+        this.selectRow = new EventEmitter();
+        this.dblClickRow = new EventEmitter();
+        this.saveRow = new EventEmitter();
+        this.deleteRow = new EventEmitter();
+        this.addRow = new EventEmitter();
+        this.rowVisible = new EventEmitter();
+        this.columns = [];
+        this.headerColumns = [];
+        this._data = [];
+        this.disabledRows = [];
+        this._prepared = false;
+    }
+    set content(columnComponents) {
+        this._setColumns(columnComponents.toArray());
+        this._prepareData();
+    }
+    set data(value) {
+        this._data = value;
+        this._prepareData();
+        this.dataChanged.next();
+    }
+    get data() {
+        return this._data;
+    }
+    set extraColumns(value) {
+        this._setColumns(value);
+    }
+    handleMouseMove(event) {
+        if (this.resizable && event.buttons === 1 && this._columnForResize) {
+            // this._columnForResize.width = this._columnForResize.originalWidth - (this._startMousePositionX - event.clientX);
+        }
+    }
+    handleMouseUp(event) {
+        this._startMousePositionX = undefined;
+        this._columnForResize = undefined;
+    }
+    handleSizerMouseDown(event, column) {
+        this._setWidthOfAllColumns();
+        this._startMousePositionX = event.clientX;
+        this._columnForResize = column;
+        this._columnForResize.originalWidth = this._columnForResize.width;
+    }
+    handleCanDragDrop(drag, drop) {
+        return true;
+    }
+    handleDrop(event) {
+        try {
+            const from = event.previousIndex;
+            const to = event.currentIndex;
+            if (from === to) {
+                return;
+            }
+            if (this.emitDragDrop) {
+                this.onDrop.next({ from: from, to: to });
+            }
+            else {
+                moveItemInArray(this.data, from, to);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    isSingleColumnRow(row) {
+        return row.hasOwnProperty('singleColumnIndex');
+    }
+    singleColumnIndex(row) {
+        return row.singleColumnIndex;
+    }
+    prepareDataRow(row, index) {
+    }
+    _setColumns(columns) {
+        this.columns.push(...columns);
+        this.columns.sort((a, b) => a.order < b.order ? -1 : 1);
+    }
+    _prepareData() {
+        if (this._prepared) {
+            return;
+        }
+        this.disabledRows.length = 0;
+        if (this.columns && this.columns.length > 0) {
+            this.headerColumns = this.columns.filter(c => !c.singleColumn);
+            let singleColumnIndex = -1;
+            for (let i = 0; i < this.columns.length; i++) {
+                if (this.columns[i].singleColumn) {
+                    singleColumnIndex = i;
+                    break;
+                }
+            }
+            // first check if there's single column data
+            if (singleColumnIndex > -1 && this.data && this.data.length > 0) {
+                const field = this.columns[singleColumnIndex].field;
+                for (let i = 0; i < this.data.length; i++) { // then mark row as single column row
+                    if (this.data[i][field] !== undefined && this.data[i][field] !== null && this.data[i][field] !== "") {
+                        // bit nasty to add prop, but cool for now
+                        this.data[i].singleColumnIndex = singleColumnIndex;
+                    }
+                    this.prepareDataRow(this.data[i], i);
+                }
+            }
+            this._prepared = true;
+        }
+        this._resizeColumnsToFit();
+    }
+    _resizeColumnsToFit() {
+        const calculateColumns = this.columns.filter(c => !c.autoFit && !c.width);
+        for (let i = 0; i < calculateColumns.length; i++) {
+            calculateColumns[i].width = `${100 / calculateColumns.length}%`;
+        }
+    }
+    _setWidthOfAllColumns() {
+        this.columns.forEach((column) => {
+            if ((column.width === undefined || column.width === null) && column.elementRef && column.elementRef.nativeElement) {
+                const rect = column.elementRef.nativeElement.getBoundingClientRect();
+                column.width = rect.width;
+            }
+        });
+    }
+}
+BaseSimpleGridComponent.decorators = [
+    { type: Directive }
+];
+BaseSimpleGridComponent.propDecorators = {
+    content: [{ type: ContentChildren, args: [SimpleGridColumnDirective,] }],
+    data: [{ type: Input }],
+    dragDropEnabled: [{ type: Input }],
+    resizable: [{ type: Input }],
+    inlineEdit: [{ type: Input }],
+    showEdit: [{ type: Input }],
+    showToolbar: [{ type: Input }],
+    autoAddRow: [{ type: Input }],
+    emitDragDrop: [{ type: Input }],
+    extraColumns: [{ type: Input }],
+    onDrop: [{ type: Output }],
+    selectRow: [{ type: Output }],
+    dblClickRow: [{ type: Output }],
+    saveRow: [{ type: Output }],
+    deleteRow: [{ type: Output }],
+    addRow: [{ type: Output }],
+    rowVisible: [{ type: Output }],
+    handleMouseMove: [{ type: HostListener, args: ['document:mousemove', ['$event'],] }],
+    handleMouseUp: [{ type: HostListener, args: ['document:mouseup', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-simple-grid.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/simple-grid/base-simple-grid.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {ContentChildren, Directive, EventEmitter, HostListener, Input, Output, QueryList, ViewChildren} from \"@angular/core\";\r\nimport {SimpleGridColumnDirective} from \"./simple-grid-column.directive\";\r\nimport {CdkDrag, CdkDragDrop, CdkDropList, moveItemInArray} from \"@angular/cdk/drag-drop\";\r\nimport {Subject} from \"rxjs\";\r\n\r\n@Directive()\r\nexport abstract class BaseSimpleGridComponent {\r\n  public readonly MIN_COLUMN_WIDTH: number = 50;\r\n  public readonly dataChanged: Subject<void> = new Subject<void>();\r\n\r\n  @ContentChildren(SimpleGridColumnDirective) set content(columnComponents: QueryList<SimpleGridColumnDirective>) {\r\n    this._setColumns(columnComponents.toArray());\r\n    this._prepareData();\r\n  }\r\n\r\n  @Input()\r\n  public set data(value: Object[]) {\r\n    this._data = value;\r\n    this._prepareData();\r\n    this.dataChanged.next();\r\n  }\r\n\r\n  public get data(): Object[] {\r\n    return this._data;\r\n  }\r\n\r\n  @Input()\r\n  public dragDropEnabled: boolean = false;\r\n\r\n  @Input()\r\n  public resizable: boolean = false;\r\n\r\n  @Input()\r\n  public inlineEdit: boolean = false;\r\n\r\n  @Input()\r\n  public showEdit: boolean = false;\r\n\r\n  @Input()\r\n  public showToolbar: boolean = false;\r\n\r\n  @Input()\r\n  public autoAddRow: boolean = false;\r\n\r\n  /**\r\n   * Should component emit drag and drop actions instead of handle\r\n   * (update collection) by itself\r\n   */\r\n  @Input()\r\n  public emitDragDrop: boolean = false;\r\n\r\n  @Input()\r\n  public set extraColumns(value: SimpleGridColumnDirective[]) {\r\n    this._setColumns(value);\r\n  }\r\n\r\n  @Output()\r\n  public onDrop: EventEmitter<{from: number, to: number}> = new EventEmitter<{from: number; to: number}>();\r\n\r\n  @Output()\r\n  public selectRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public dblClickRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public saveRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public deleteRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public addRow: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Output()\r\n  public rowVisible: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @HostListener('document:mousemove', ['$event'])\r\n  public handleMouseMove(event: MouseEvent): void {\r\n    if (this.resizable && event.buttons === 1 && this._columnForResize) {\r\n      // this._columnForResize.width = this._columnForResize.originalWidth - (this._startMousePositionX - event.clientX);\r\n    }\r\n  }\r\n\r\n  @HostListener('document:mouseup', ['$event'])\r\n  public handleMouseUp(event: MouseEvent): void {\r\n    this._startMousePositionX = undefined;\r\n    this._columnForResize = undefined;\r\n  }\r\n\r\n  public columns: SimpleGridColumnDirective[] = [];\r\n  public headerColumns: SimpleGridColumnDirective[] = [];\r\n\r\n  protected _data: Object[] = [];\r\n  protected disabledRows: number[] = [];\r\n\r\n  private _columnForResize: SimpleGridColumnDirective;\r\n  private _prepared: boolean = false;\r\n  private _startMousePositionX: number;\r\n\r\n  public handleSizerMouseDown(event: MouseEvent, column: SimpleGridColumnDirective): void {\r\n    this._setWidthOfAllColumns();\r\n    this._startMousePositionX = event.clientX;\r\n    this._columnForResize = column;\r\n    this._columnForResize.originalWidth = this._columnForResize.width;\r\n  }\r\n\r\n  public handleCanDragDrop(drag: CdkDrag, drop: CdkDropList): boolean {\r\n    return true;\r\n  }\r\n\r\n  public handleDrop(event: CdkDragDrop<Object[]>): void {\r\n    try {\r\n      const from: number = event.previousIndex;\r\n      const to: number = event.currentIndex;\r\n      if (from === to) {\r\n        return;\r\n      }\r\n      if (this.emitDragDrop) {\r\n        this.onDrop.next({from: from, to: to});\r\n      } else {\r\n        moveItemInArray(this.data, from, to);\r\n      }\r\n    } catch (e) {\r\n      console.error(e);\r\n    }\r\n  }\r\n\r\n  public isSingleColumnRow(row: Object): boolean {\r\n    return row.hasOwnProperty('singleColumnIndex');\r\n  }\r\n\r\n  public singleColumnIndex(row: Object): number {\r\n    return (row as any).singleColumnIndex;\r\n  }\r\n\r\n  protected prepareDataRow(row: any, index: number): void {\r\n\r\n  }\r\n\r\n  private _setColumns(columns: SimpleGridColumnDirective[]): void {\r\n    this.columns.push(...columns);\r\n    this.columns.sort((a, b) => a.order < b.order ? -1 : 1);\r\n  }\r\n\r\n  private _prepareData(): void {\r\n    if (this._prepared) {\r\n      return;\r\n    }\r\n    this.disabledRows.length = 0;\r\n\r\n    if (this.columns && this.columns.length > 0) {\r\n      this.headerColumns = this.columns.filter(c => !c.singleColumn);\r\n      let singleColumnIndex: number = -1;\r\n      for (let i = 0; i < this.columns.length; i++) {\r\n        if (this.columns[i].singleColumn) {\r\n          singleColumnIndex = i;\r\n          break;\r\n        }\r\n      }\r\n      // first check if there's single column data\r\n      if (singleColumnIndex > -1 && this.data && this.data.length > 0) {\r\n        const field: string = this.columns[singleColumnIndex].field;\r\n        for (let i = 0; i < this.data.length; i++) { // then mark row as single column row\r\n          if (this.data[i][field] !== undefined && this.data[i][field] !== null && this.data[i][field] !== \"\") {\r\n            // bit nasty to add prop, but cool for now\r\n            (this.data[i] as any).singleColumnIndex = singleColumnIndex;\r\n          }\r\n          this.prepareDataRow(this.data[i], i);\r\n        }\r\n      }\r\n\r\n      this._prepared = true;\r\n    }\r\n    this._resizeColumnsToFit();\r\n  }\r\n\r\n  private _resizeColumnsToFit(): void {\r\n    const calculateColumns: SimpleGridColumnDirective[] = this.columns.filter(c => !c.autoFit && !c.width);\r\n    for (let i = 0; i < calculateColumns.length; i++) {\r\n      calculateColumns[i].width = `${100 / calculateColumns.length}%`;\r\n    }\r\n  }\r\n\r\n  private _setWidthOfAllColumns(): void {\r\n    this.columns.forEach((column: SimpleGridColumnDirective) => {\r\n      if ((column.width === undefined || column.width === null) && column.elementRef && column.elementRef.nativeElement) {\r\n        const rect: ClientRect = column.elementRef.nativeElement.getBoundingClientRect();\r\n        column.width = rect.width;\r\n      }\r\n    });\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/lib/components/simple-grid/simple-grid-cell.component.js

@@ -0,0 +1,172 @@
+import { ChangeDetectorRef, Component, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { ColumnAlign } from "./simple-grid-column.directive";
+import { BaseInputComponent } from "../base/base-input.component";
+export class SimpleGridCellComponent {
+    constructor(_changeDetector) {
+        this._changeDetector = _changeDetector;
+        this.defaultTextAlign = ColumnAlign.Left;
+        this._editMode = false;
+        this.cellClick = new EventEmitter();
+        this._fieldEditMode = false;
+        this._focused = false;
+    }
+    get editMode() {
+        return this._editMode;
+    }
+    set editMode(value) {
+        this._editMode = value;
+    }
+    set editTemplateContent(template) {
+        if (template) {
+            this._editTemplate = template;
+            this._setFocusComponent();
+        }
+    }
+    set noEditTemplateContent(template) {
+        if (template) {
+            this._template = template;
+            this._setFocusComponent();
+        }
+    }
+    set noTemplateContent(template) {
+        if (template) {
+            this._inputTemplate = template;
+            this._setFocusComponent();
+        }
+    }
+    set fieldEditMode(value) {
+        this._fieldEditMode = value;
+        this._setFocusComponent();
+    }
+    get fieldEditMode() {
+        return this._fieldEditMode;
+    }
+    showClass() {
+        return true;
+    }
+    handleClick(event) {
+        if (this.column && !this.column.readonly) {
+            this.cellClick.next();
+        }
+    }
+    _setFocusComponent() {
+        if (this._editMode && this.fieldEditMode) {
+            const element = this._getElement();
+            if (element) {
+                const focusEvent = this._createNewEvent(element, 'focus');
+                element.focus();
+                element.dispatchEvent(focusEvent);
+                this._focused = true;
+            }
+        }
+        else {
+            if (this._focused) {
+                const element = this._getElement();
+                if (element) {
+                    const blurEvent = this._createNewEvent(element, 'blur');
+                    element.blur();
+                    element.dispatchEvent(blurEvent);
+                }
+                this._focused = false;
+            }
+        }
+        this._detectChanges();
+    }
+    _getFirstFormInput(parent) {
+        if (parent) {
+            const collection = Array.from(parent.getElementsByTagName('input'));
+            const otherCollection = Array.from(parent.getElementsByTagName('textarea'));
+            otherCollection.map(o => collection.push(o));
+            if (collection.length > 0) {
+                return collection[0];
+            }
+        }
+    }
+    _createNewEvent(element, eventType) {
+        let event;
+        if ("createEvent" in document) {
+            event = document.createEvent("Event");
+            event.initEvent(eventType, true, true);
+        }
+        else if ("Event" in window) {
+            event = new Event(eventType, { bubbles: true, cancelable: true });
+        }
+        return event;
+    }
+    _getElement() {
+        let templ;
+        if (this._editTemplate) {
+            templ = this._editTemplate;
+        }
+        else if (this._template) {
+            templ = this._template;
+        }
+        else {
+            templ = this._inputTemplate;
+        }
+        if (templ) {
+            if (templ && templ.elementRef) {
+                const inputElement = this._getFirstFormInput(templ.elementRef.nativeElement.parentElement);
+                if (inputElement) {
+                    return inputElement;
+                }
+            }
+        }
+    }
+    _detectChanges() {
+        this._changeDetector.detectChanges();
+    }
+}
+SimpleGridCellComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-simple-grid-cell",
+                template: `
+      <div class="simple-grid-column-cell-value" [ngClass]="column.textAlign ? column.textAlign : defaultTextAlign">
+          <ng-container *ngIf="editMode; else noInlineEdit">
+              <div class="simple-grid-column-cell-field">
+                <ng-container #editTemplate *ngIf="column.editTemplate; else noEditTemplate"
+                              [ngTemplateOutlet]="column.editTemplate"
+                              [ngTemplateOutletContext]="{value: row[column.field], row: row}"></ng-container>
+                <ng-template #noEditTemplate>
+                    <ng-container *ngIf="column.template; else noTemplate">
+                        <ng-container [ngTemplateOutlet]="column.template"
+                                      [ngTemplateOutletContext]="{value: row[column.field], row: row}"></ng-container>
+                    </ng-container>
+                    <ng-template #noTemplate>
+                        <co-input-text [(model)]="row[column.field]" [required]="column.required"></co-input-text>
+                    </ng-template>
+                </ng-template>
+              </div>
+          </ng-container>
+          <ng-template #noInlineEdit>
+              <div class="simple-grid-column-cell-field">
+                <ng-container *ngIf="column.template; else noTemplate">
+                    <ng-container [ngTemplateOutlet]="column.template"
+                                  [ngTemplateOutletContext]="{value: row[column.field], row: row}"></ng-container>
+                </ng-container>
+                <ng-template #noTemplate>
+                    <span [textContent]="column.getFieldValue(row[column.field])"></span>
+                </ng-template>
+              </div>
+          </ng-template>
+      </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+SimpleGridCellComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+SimpleGridCellComponent.propDecorators = {
+    editMode: [{ type: Input }],
+    editTemplateContent: [{ type: ViewChild, args: ["editTemplate", { read: BaseInputComponent },] }],
+    noEditTemplateContent: [{ type: ViewChild, args: ["noEditTemplate",] }],
+    noTemplateContent: [{ type: ViewChild, args: ["noTemplate",] }],
+    column: [{ type: Input }],
+    row: [{ type: Input }],
+    fieldEditMode: [{ type: Input }],
+    cellClick: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-simple-grid-cell",] }],
+    handleClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-grid-cell.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/simple-grid/simple-grid-cell.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  HostBinding,\r\n  HostListener,\r\n  Input, OnChanges,\r\n  Output, SimpleChanges,\r\n  TemplateRef,\r\n  ViewChild,\r\n  ViewEncapsulation\r\n} from '@angular/core';\r\nimport { ColumnAlign, SimpleGridColumnDirective } from \"./simple-grid-column.directive\";\r\nimport { BaseInputComponent } from \"../base/base-input.component\";\r\n\r\n@Component({\r\n  selector: \"co-simple-grid-cell\",\r\n  template: `\r\n      <div class=\"simple-grid-column-cell-value\" [ngClass]=\"column.textAlign ? column.textAlign : defaultTextAlign\">\r\n          <ng-container *ngIf=\"editMode; else noInlineEdit\">\r\n              <div class=\"simple-grid-column-cell-field\">\r\n                <ng-container #editTemplate *ngIf=\"column.editTemplate; else noEditTemplate\"\r\n                              [ngTemplateOutlet]=\"column.editTemplate\"\r\n                              [ngTemplateOutletContext]=\"{value: row[column.field], row: row}\"></ng-container>\r\n                <ng-template #noEditTemplate>\r\n                    <ng-container *ngIf=\"column.template; else noTemplate\">\r\n                        <ng-container [ngTemplateOutlet]=\"column.template\"\r\n                                      [ngTemplateOutletContext]=\"{value: row[column.field], row: row}\"></ng-container>\r\n                    </ng-container>\r\n                    <ng-template #noTemplate>\r\n                        <co-input-text [(model)]=\"row[column.field]\" [required]=\"column.required\"></co-input-text>\r\n                    </ng-template>\r\n                </ng-template>\r\n              </div>\r\n          </ng-container>\r\n          <ng-template #noInlineEdit>\r\n              <div class=\"simple-grid-column-cell-field\">\r\n                <ng-container *ngIf=\"column.template; else noTemplate\">\r\n                    <ng-container [ngTemplateOutlet]=\"column.template\"\r\n                                  [ngTemplateOutletContext]=\"{value: row[column.field], row: row}\"></ng-container>\r\n                </ng-container>\r\n                <ng-template #noTemplate>\r\n                    <span [textContent]=\"column.getFieldValue(row[column.field])\"></span>\r\n                </ng-template>\r\n              </div>\r\n          </ng-template>\r\n      </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class SimpleGridCellComponent {\r\n  get editMode(): boolean {\r\n    return this._editMode;\r\n  }\r\n  @Input()\r\n  set editMode(value: boolean) {\r\n    this._editMode = value;\r\n  }\r\n  public readonly defaultTextAlign: ColumnAlign = ColumnAlign.Left;\r\n\r\n  @ViewChild(\"editTemplate\", {read: BaseInputComponent}) set editTemplateContent(template) {\r\n    if (template) {\r\n      this._editTemplate = template;\r\n      this._setFocusComponent();\r\n    }\r\n  }\r\n\r\n  @ViewChild(\"noEditTemplate\") set noEditTemplateContent(template) {\r\n    if (template) {\r\n      this._template = template;\r\n      this._setFocusComponent();\r\n    }\r\n  }\r\n\r\n  @ViewChild(\"noTemplate\") set noTemplateContent(template) {\r\n    if (template) {\r\n      this._inputTemplate = template;\r\n      this._setFocusComponent();\r\n    }\r\n  }\r\n\r\n  @Input()\r\n  public column: SimpleGridColumnDirective;\r\n\r\n  @Input()\r\n  public row: {};\r\n\r\n  private _editMode: boolean = false;\r\n\r\n  @Input()\r\n  public set fieldEditMode(value: boolean) {\r\n    this._fieldEditMode = value;\r\n    this._setFocusComponent();\r\n  }\r\n\r\n  public get fieldEditMode(): boolean {\r\n    return this._fieldEditMode;\r\n  }\r\n\r\n  @Output()\r\n  public cellClick: EventEmitter<MouseEvent> = new EventEmitter<MouseEvent>();\r\n\r\n  @HostBinding(\"class.co-simple-grid-cell\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  @HostListener('click', ['$event'])\r\n  public handleClick(event: MouseEvent): void {\r\n    if (this.column && !this.column.readonly) {\r\n      this.cellClick.next();\r\n    }\r\n  }\r\n\r\n  private _fieldEditMode: boolean = false;\r\n  private _focused: boolean = false;\r\n  private _editTemplate: TemplateRef<any>;\r\n  private _template: TemplateRef<any>;\r\n  private _inputTemplate: TemplateRef<any>;\r\n\r\n  constructor(private _changeDetector: ChangeDetectorRef) {\r\n  }\r\n\r\n  private _setFocusComponent(): void {\r\n    if (this._editMode && this.fieldEditMode) {\r\n      const element = this._getElement();\r\n      if (element) {\r\n        const focusEvent = this._createNewEvent(element, 'focus');\r\n        element.focus();\r\n        element.dispatchEvent(focusEvent);\r\n        this._focused = true;\r\n      }\r\n    } else {\r\n      if (this._focused) {\r\n        const element = this._getElement();\r\n        if (element) {\r\n          const blurEvent = this._createNewEvent(element, 'blur');\r\n          element.blur();\r\n          element.dispatchEvent(blurEvent);\r\n        }\r\n        this._focused = false;\r\n      }\r\n    }\r\n    this._detectChanges();\r\n  }\r\n\r\n  private _getFirstFormInput(parent: any): any {\r\n    if (parent) {\r\n      const collection = Array.from(parent.getElementsByTagName('input'));\r\n      const otherCollection = Array.from(parent.getElementsByTagName('textarea'));\r\n      otherCollection.map(o => collection.push(o));\r\n      if (collection.length > 0) {\r\n        return collection[0];\r\n      }\r\n    }\r\n  }\r\n\r\n  private _createNewEvent(element: any, eventType: string): Event {\r\n    let event;\r\n    if (\"createEvent\" in document) {\r\n      event = document.createEvent(\"Event\");\r\n      event.initEvent(eventType, true, true);\r\n    } else if (\"Event\" in window) {\r\n      event = new Event(eventType, { bubbles: true, cancelable: true });\r\n    }\r\n    return event;\r\n  }\r\n\r\n  private _getElement(): HTMLElement {\r\n    let templ: TemplateRef<any>;\r\n    if (this._editTemplate) {\r\n      templ = this._editTemplate;\r\n    } else if (this._template) {\r\n      templ = this._template;\r\n    } else {\r\n      templ = this._inputTemplate;\r\n    }\r\n    if (templ) {\r\n      if (templ && templ.elementRef) {\r\n        const inputElement = this._getFirstFormInput(templ.elementRef.nativeElement.parentElement);\r\n        if (inputElement) {\r\n          return inputElement;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _detectChanges(): void {\r\n    this._changeDetector.detectChanges();\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/simple-grid/simple-grid-column.directive.js

@@ -0,0 +1,111 @@
+import { ContentChild, Directive, ElementRef, Input } from '@angular/core';
+export var ColumnAlign;
+(function (ColumnAlign) {
+    ColumnAlign["Left"] = "left-align";
+    ColumnAlign["Center"] = "center-align";
+    ColumnAlign["Right"] = "right-align";
+})(ColumnAlign || (ColumnAlign = {}));
+export class SimpleGridColumnDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.resizable = true;
+        this.required = false;
+        this.autoFit = false;
+        this.readonly = false;
+        this.order = 0;
+        this.singleColumn = false;
+    }
+    set headerTemplate(template) {
+        if (template) {
+            this._headerTemplate = template;
+        }
+    }
+    get headerTemplate() {
+        return this._headerTemplate;
+    }
+    set template(template) {
+        if (template) {
+            this._template = template;
+        }
+    }
+    get template() {
+        return this._template;
+    }
+    set editTemplate(template) {
+        if (template) {
+            this._editTemplate = template;
+        }
+    }
+    get editTemplate() {
+        return this._editTemplate;
+    }
+    set width(value) {
+        if (typeof value === 'string') {
+            if (value.indexOf('%')) {
+                this.widthPercentage = value;
+            }
+            else {
+                this._width = value;
+            }
+        }
+        else {
+            this._width = value;
+        }
+    }
+    get width() {
+        return this._width;
+    }
+    ngOnInit() {
+        this._setSingleColumnProps();
+    }
+    ngOnDestroy() {
+        this._headerTemplate = undefined;
+        this._template = undefined;
+        this._editTemplate = undefined;
+    }
+    getFieldValue(value) {
+        if (this.collection && this.displayField) {
+            const result = this.collection.find(c => c[this.codeField] === value);
+            if (result) {
+                return result[this.displayField];
+            }
+        }
+        return value;
+    }
+    _setSingleColumnProps() {
+        if (this.singleColumn) {
+            this.resizable = false;
+            this.readonly = true;
+            this.width = 0;
+        }
+    }
+}
+SimpleGridColumnDirective._MinManualResizeWidthPx = 50;
+SimpleGridColumnDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "co-simple-grid-column"
+            },] }
+];
+SimpleGridColumnDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+SimpleGridColumnDirective.propDecorators = {
+    headerTemplate: [{ type: ContentChild, args: ['headerTemplate',] }],
+    template: [{ type: ContentChild, args: ['template',] }],
+    editTemplate: [{ type: ContentChild, args: ['editTemplate',] }],
+    headerText: [{ type: Input }],
+    field: [{ type: Input }],
+    codeField: [{ type: Input }],
+    displayField: [{ type: Input }],
+    textAlign: [{ type: Input }],
+    format: [{ type: Input }],
+    resizable: [{ type: Input }],
+    required: [{ type: Input }],
+    autoFit: [{ type: Input }],
+    width: [{ type: Input }],
+    readonly: [{ type: Input }],
+    collection: [{ type: Input }],
+    order: [{ type: Input }],
+    singleColumn: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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