@colijnit/corecomponents_v12 12.2.26 → 12.2.27

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

@@ -1,125 +1,125 @@
-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",
+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">
@@ -150,23 +150,23 @@ SimpleGridCellComponent.decorators = [
               </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'],] }]
-};
+  `,
+                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

@@ -1,111 +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 }]
-};
+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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