@michalrakus/x-react-web-lib 1.1.0 → 1.2.0

package/lib/components/XDropdown.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="react" />
 import { XFormComponent, XFormComponentProps } from "./XFormComponent";
 import { XAssoc } from "../serverApi/XEntityMetadata";
-export interface XDropdownProps extends XFormComponentProps {
+import { XObject } from "./XObject";
+export interface XDropdownProps extends XFormComponentProps<XObject> {
     assocField: string;
     displayField: string;
 }
-export declare class XDropdown extends XFormComponent<XDropdownProps> {
+export declare class XDropdown extends XFormComponent<XObject, XDropdownProps> {
     protected xAssoc: XAssoc;
     state: {
         options: any[];

package/lib/components/XDropdown.js

@@ -102,7 +102,7 @@ var XDropdown = /** @class */ (function (_super) {
         else {
             newValueOrNull = e.target.value;
         }
-        this.onValueChangeBase(newValueOrNull);
+        this.onValueChangeBase(newValueOrNull, this.props.onChange);
     };
     XDropdown.prototype.componentDidMount = function () {
         this.findOptions(this.props.form.getEntity(), this.props.assocField);

package/lib/components/XFieldChangeEvent.d.ts

@@ -0,0 +1,11 @@
+import { OperationType } from "./XUtils";
+import { XObject } from "./XObject";
+export interface XFieldChangeEvent<M = XObject> {
+    object: M;
+    assocObjectChange?: OperationType;
+}
+export interface XTableFieldChangeEvent<M = XObject, R = any> {
+    object: M;
+    tableRow: R;
+    assocObjectChange?: OperationType;
+}

package/lib/components/XFieldChangeEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/components/XFormBase.d.ts

@@ -1,13 +1,14 @@
 import { Component } from "react";
 import { XObject } from "./XObject";
 import { OperationType } from "./XUtils";
-import { XFormComponent } from "./XFormComponent";
-import { XFormDataTable2 } from "./XFormDataTable2";
+import { FieldOnChange, XFormComponent } from "./XFormComponent";
+import { TableFieldOnChange, XFormDataTable2, XRowTechData } from "./XFormDataTable2";
 import { XErrorMap, XErrors } from "./XErrors";
+export type XOnSaveOrCancelProp = (object: XObject | null, objectChange: OperationType) => void;
 export interface FormProps {
     id?: number;
     object?: XObject;
-    onSaveOrCancel?: (object: XObject | null, objectChange: OperationType) => void;
+    onSaveOrCancel?: XOnSaveOrCancelProp;
 }
 export declare function Form(entity: string): <T extends new (...args: any[]) => {}>(constructor: T) => {
     new (...args: any[]): {
@@ -21,7 +22,7 @@ export declare abstract class XFormBase extends Component<FormProps> {
         object: XObject | null;
         errorMap: XErrorMap;
     } | any;
-    xFormComponentList: Array<XFormComponent<any>>;
+    xFormComponentList: Array<XFormComponent<any, any>>;
     xFormDataTableList: Array<XFormDataTable2>;
     constructor(props: FormProps);
     componentDidMount(): Promise<void>;
@@ -29,21 +30,28 @@ export declare abstract class XFormBase extends Component<FormProps> {
     getXObject(): XObject;
     getObject(): any;
     isAddRow(): any;
-    onFieldChange(field: string, value: any, error?: string | undefined): void;
-    onTableFieldChange(assocField: string, rowIndex: number, field: string, value: any): void;
-    onObjectDataChange(): void;
+    onFieldChange(field: string, value: any, error?: string | undefined, onChange?: FieldOnChange, assocObjectChange?: OperationType): void;
+    onTableFieldChange(rowData: any, field: string, value: any, error?: string | undefined, onChange?: TableFieldOnChange, assocObjectChange?: OperationType): void;
+    /**
+     * @deprecated - mal by sa pouzivat onTableFieldChange
+     */
+    onObjectDataChange(row?: any, onChange?: TableFieldOnChange): void;
+    setStateXForm(): void;
     onTableAddRow(assocField: string, newRow: any, dataKey?: string, selectedRow?: {}): void;
     static getNextRowId(rowList: any[], dataKey: string): number;
     onTableRemoveRow(assocField: string, row: {}): void;
+    static getXRowTechData(row: any): XRowTechData;
     addField(field: string): void;
-    addXFormComponent(xFormComponent: XFormComponent<any>): void;
-    findXFormComponent(field: string): XFormComponent<any> | undefined;
+    addXFormComponent(xFormComponent: XFormComponent<any, any>): void;
+    findXFormComponent(field: string): XFormComponent<any, any> | undefined;
     addXFormDataTable(xFormDataTable: XFormDataTable2): void;
     onClickSave(): Promise<void>;
     onClickCancel(): void;
     validateSave(): boolean;
     validateForm(): XErrorMap;
     fieldValidation(): XErrorMap;
+    preInitForm(object: XObject, operationType: OperationType.Insert | OperationType.Update): void;
     validate(object: XObject): XErrors;
     preSave(object: XObject): void;
+    saveRow(): Promise<any>;
 }

package/lib/components/XFormBase.js

@@ -92,7 +92,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.XFormBase = exports.Form = void 0;
 var react_1 = require("react");
 var XUtils_1 = require("./XUtils");
-var XUtilsCommon_1 = require("../serverApi/XUtilsCommon");
 // class decorator ktory nastavuje property entity (dalo by sa to nastavovat v konstruktore ale decorator je menej ukecany)
 // ma sa pouzivat len na triedach odvodenych od XFormBase - obmedzenie som vsak nevedel nakodit
 // property sa nastavi az po zbehnuti konstruktora
@@ -144,10 +143,11 @@ var XFormBase = /** @class */ (function (_super) {
     }
     XFormBase.prototype.componentDidMount = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var object;
+            var object, operationType;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        console.log("volany XFormBase.componentDidMount()");
                         // kontrola (musi byt tu, v konstruktore este property nie je nastavena)
                         if (this.entity === undefined) {
                             throw "XFormBase: Property entity is not defined - use decorator @Form.";
@@ -155,18 +155,21 @@ var XFormBase = /** @class */ (function (_super) {
                         if (!(this.props.id !== undefined)) return [3 /*break*/, 2];
                         return [4 /*yield*/, XUtils_1.XUtils.fetchById(this.entity, Array.from(this.fields), this.props.id)];
                     case 1:
+                        //console.log('XFormBase.componentDidMount ide nacitat objekt');
+                        //console.log(this.fields);
                         object = _a.sent();
-                        //console.log('XFormBase.componentDidMount nacital objekt:');
-                        //console.log(object);
-                        // const price = (object as any).price;
-                        // console.log(typeof price);
-                        // console.log(price);
-                        // const date = (object as any).carDate;
-                        // console.log(typeof date);
-                        // console.log(date);
-                        this.setState({ object: object });
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
+                        operationType = XUtils_1.OperationType.Update;
+                        return [3 /*break*/, 3];
+                    case 2:
+                        // add new row
+                        object = this.state.object;
+                        operationType = XUtils_1.OperationType.Insert;
+                        _a.label = 3;
+                    case 3:
+                        this.preInitForm(object, operationType);
+                        console.log("volany XFormBase.componentDidMount() - ideme setnut object");
+                        this.setState({ object: object }, function () { return console.log("volany XFormBase.componentDidMount() - callback setState"); });
+                        return [2 /*return*/];
                 }
             });
         });
@@ -189,26 +192,52 @@ var XFormBase = /** @class */ (function (_super) {
     XFormBase.prototype.isAddRow = function () {
         return this.props.id === undefined;
     };
-    XFormBase.prototype.onFieldChange = function (field, value, error) {
+    XFormBase.prototype.onFieldChange = function (field, value, error, onChange, assocObjectChange) {
         var object = this.getXObject();
         object[field] = value;
         var errorMap = this.state.errorMap;
         errorMap[field] = __assign(__assign({}, errorMap[field]), { onChange: error });
+        // tu zavolame onChange komponentu - object uz ma zapisanu zmenenu hodnotu, onChange nasledne zmeni dalsie hodnoty a nasledne sa zavola setState
+        if (onChange) {
+            onChange({ object: object, assocObjectChange: assocObjectChange });
+        }
         // TODO - tu mozno treba setnut funkciu - koli moznej asynchronicite
         this.setState({ object: object, errorMap: errorMap });
     };
-    XFormBase.prototype.onTableFieldChange = function (assocField, rowIndex, field, value) {
+    XFormBase.prototype.onTableFieldChange = function (rowData, field, value, error, onChange, assocObjectChange) {
         var object = this.getXObject();
-        var rowList = object[assocField];
-        rowList[rowIndex][field] = value;
+        rowData[field] = value;
+        // nastavime error do rowData do tech fieldu
+        var errorMap = XFormBase.getXRowTechData(rowData).errorMap;
+        errorMap[field] = __assign(__assign({}, errorMap[field]), { onChange: error });
+        // tu zavolame onChange komponentu - object uz ma zapisanu zmenenu hodnotu, onChange nasledne zmeni dalsie hodnoty a nasledne sa zavola setState
+        if (onChange) {
+            onChange({ object: object, tableRow: rowData, assocObjectChange: assocObjectChange });
+        }
         // TODO - tu mozno treba setnut funkciu - koli moznej asynchronicite
-        this.setState({ object: object });
+        this.setState({ object: object /*, errorMap: errorMap*/ });
     };
-    XFormBase.prototype.onObjectDataChange = function () {
+    /**
+     * @deprecated - mal by sa pouzivat onTableFieldChange
+     */
+    XFormBase.prototype.onObjectDataChange = function (row, onChange) {
         var object = this.state.object;
+        // tu zavolame onChange komponentu - object uz ma zapisanu zmenenu hodnotu, onChange nasledne zmeni dalsie hodnoty a nasledne sa zavola setState
+        if (onChange) {
+            // TODO - assocObjectChange dorobit
+            onChange({ object: object, tableRow: row, assocObjectChange: undefined });
+        }
         // TODO - tu mozno treba setnut funkciu - koli moznej asynchronicite
         this.setState({ object: object });
     };
+    // lepsi nazov ako onObjectDataChange
+    // ak niekto zmenil this.state.object alebo this.state.errorMap, zmena sa prejavi vo formulari
+    // pouzivame napr. po zavolani onChange na XInputText
+    XFormBase.prototype.setStateXForm = function () {
+        // TODO - je to ok ze object menime takto?
+        // TODO - tu mozno treba setnut funkciu - koli moznej asynchronicite
+        this.setState({ object: this.state.object, errorMap: this.state.errorMap });
+    };
     XFormBase.prototype.onTableAddRow = function (assocField, newRow, dataKey, selectedRow) {
         var object = this.getXObject();
         var rowList = object[assocField];
@@ -271,6 +300,21 @@ var XFormBase = /** @class */ (function (_super) {
         // TODO - tu mozno treba setnut funkciu - koli moznej asynchronicite
         this.setState({ object: object });
     };
+    // tato metoda (aj vsetky ostatne metody precujuce s row-mi) by mali byt skor na XFormDataTable2 (ta pozna "assocField" (OneToMany asociaciu))
+    XFormBase.getXRowTechData = function (row) {
+        // ak este nemame rowTechData, tak ho vytvorime
+        if (row.__x_rowTechData === undefined) {
+            // field '__x_rowTechData' vytvorime takymto specialnym sposobom, aby mal "enumerable: false", tympadom ho JSON.stringify nezaserializuje
+            // pri posielani objektu formulara na backend (pozor, zaroven sa neda tento field iterovat cez in operator a pod.)
+            var xRowTechData = { xFormComponentDTList: [], errorMap: {} };
+            Object.defineProperty(row, '__x_rowTechData', {
+                value: xRowTechData,
+                writable: false,
+                enumerable: false
+            });
+        }
+        return row.__x_rowTechData;
+    };
     XFormBase.prototype.addField = function (field) {
         this.fields.add(field);
     };
@@ -328,7 +372,7 @@ var XFormBase = /** @class */ (function (_super) {
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, XUtils_1.XUtils.fetch('saveRow', { entity: this.getEntity(), object: this.state.object, reload: this.props.onSaveOrCancel !== undefined })];
+                        return [4 /*yield*/, this.saveRow()];
                     case 2:
                         object = _a.sent();
                         return [3 /*break*/, 4];
@@ -362,25 +406,20 @@ var XFormBase = /** @class */ (function (_super) {
     };
     XFormBase.prototype.validateSave = function () {
         var e_4, _a;
-        var _b;
         var xErrorMap = this.validateForm();
-        // zatial takto
-        var msg = "";
+        // zatial takto jednoducho
+        var msg = XUtils_1.XUtils.getErrorMessages(xErrorMap);
         try {
-            for (var _c = __values(Object.entries(xErrorMap)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var _e = __read(_d.value, 2), field = _e[0], xError = _e[1];
-                if (xError) {
-                    var errorMessage = XUtils_1.XUtils.getXErrorMessage(xError);
-                    if (errorMessage) {
-                        msg += "".concat((_b = xError.fieldLabel) !== null && _b !== void 0 ? _b : field, ": ").concat(errorMessage).concat(XUtilsCommon_1.XUtilsCommon.newLine);
-                    }
-                }
+            // este spracujeme editovatelne tabulky
+            for (var _b = __values(this.xFormDataTableList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var xFormDataTable = _c.value;
+                msg += xFormDataTable.getErrorMessages();
             }
         }
         catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
             finally { if (e_4) throw e_4.error; }
         }
@@ -415,7 +454,8 @@ var XFormBase = /** @class */ (function (_super) {
             finally { if (e_5) throw e_5.error; }
         }
         // TODO - optimalizacia - netreba setovat stav ak by sme sli prec z formulara (ak by zbehla validacia aj save a isli by sme naspet do browsu)
-        this.setState({ errorMap: xErrorMap });
+        // setujeme aj this.state.object, lebo mohli pribudnut/odbudnut chyby na rowData v editovatelnych tabulkach
+        this.setState({ object: this.state.object, errorMap: xErrorMap });
         return xErrorMap;
     };
     XFormBase.prototype.fieldValidation = function () {
@@ -441,7 +481,7 @@ var XFormBase = /** @class */ (function (_super) {
         try {
             for (var _e = __values(this.xFormDataTableList), _f = _e.next(); !_f.done; _f = _e.next()) {
                 var xFormDataTable = _f.value;
-                // TODO - validate table
+                xFormDataTable.validate();
             }
         }
         catch (e_7_1) { e_7 = { error: e_7_1 }; }
@@ -453,6 +493,9 @@ var XFormBase = /** @class */ (function (_super) {
         }
         return xErrorMap;
     };
+    // this method can be overriden in subclass if needed (to modify/save object after read from DB and before set into the form)
+    XFormBase.prototype.preInitForm = function (object, operationType) {
+    };
     // this method can be overriden in subclass if needed (custom validation)
     XFormBase.prototype.validate = function (object) {
         return {};
@@ -460,6 +503,14 @@ var XFormBase = /** @class */ (function (_super) {
     // this method can be overriden in subclass if needed (to modify object before save)
     XFormBase.prototype.preSave = function (object) {
     };
+    // this method can be overriden in subclass if needed (to use another service then default 'saveRow')
+    XFormBase.prototype.saveRow = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, XUtils_1.XUtils.fetch('saveRow', { entity: this.getEntity(), object: this.state.object, reload: this.props.onSaveOrCancel !== undefined })];
+            });
+        });
+    };
     return XFormBase;
 }(react_1.Component));
 exports.XFormBase = XFormBase;

package/lib/components/XFormComponent.d.ts

@@ -1,18 +1,24 @@
 import React, { Component } from "react";
 import { XFormBase } from "./XFormBase";
 import { XError } from "./XErrors";
-export interface XFormComponentProps {
+import { OperationType } from "./XUtils";
+import { XFieldChangeEvent } from "./XFieldChangeEvent";
+import { XCustomFilter } from "../serverApi/FindParam";
+export type FieldOnChange = (e: XFieldChangeEvent<any>) => void;
+export type XFilterProp = XCustomFilter | ((object: any) => XCustomFilter | undefined);
+export interface XFormComponentProps<T> {
     form: XFormBase;
     label?: string;
     readOnly?: boolean;
     labelStyle?: React.CSSProperties;
     inline?: boolean;
+    onChange?: FieldOnChange;
 }
-export declare abstract class XFormComponent<P extends XFormComponentProps> extends Component<P> {
+export declare abstract class XFormComponent<T, P extends XFormComponentProps<T>> extends Component<P> {
     protected constructor(props: P);
     abstract getField(): string;
     getValueFromObject(): any;
-    onValueChangeBase(value: any): void;
+    onValueChangeBase(value: any, onChange?: FieldOnChange, assocObjectChange?: OperationType): void;
     abstract isNotNull(): boolean;
     isReadOnly(): boolean;
     getLabel(): string;
@@ -25,4 +31,6 @@ export declare abstract class XFormComponent<P extends XFormComponentProps> exte
     validateNotNull(value: any): string | undefined;
     getClassNameTooltip(): {};
     getError(): string | undefined;
+    callOnChangeFromOnBlur(): void;
+    getFilterBase(filter: XFilterProp | undefined): XCustomFilter | undefined;
 }

package/lib/components/XFormComponent.js

@@ -42,9 +42,9 @@ var XFormComponent = /** @class */ (function (_super) {
         return objectValue;
     };
     // writes value into form.state.object
-    XFormComponent.prototype.onValueChangeBase = function (value) {
+    XFormComponent.prototype.onValueChangeBase = function (value, onChange, assocObjectChange) {
         var error = this.validateOnChange(value);
-        this.props.form.onFieldChange(this.getField(), value, error);
+        this.props.form.onFieldChange(this.getField(), value, error, onChange, assocObjectChange);
     };
     XFormComponent.prototype.isReadOnly = function () {
         // tuto do buducna planujeme pridat aj dynamicky readOnly, bude ho treba ukladat do form.state podobne ako sa ukladaju errory do form.state.errorMap
@@ -116,7 +116,33 @@ var XFormComponent = /** @class */ (function (_super) {
     // vrati error message z form.state.errorMap
     XFormComponent.prototype.getError = function () {
         var error = this.props.form.state.errorMap[this.getField()];
-        return error ? XUtils_1.XUtils.getXErrorMessage(error) : undefined;
+        return error ? XUtils_1.XUtils.getErrorMessage(error) : undefined;
+    };
+    XFormComponent.prototype.callOnChangeFromOnBlur = function () {
+        if (this.props.onChange) {
+            var object = this.props.form.getXObject();
+            // developer v onChange nastavi atributy na object-e
+            this.props.onChange({ object: object });
+            // rovno zavolame form.setState({...}), nech to nemusi robit developer
+            this.props.form.setStateXForm();
+        }
+    };
+    // len pre assoc fieldy sa pouziva
+    XFormComponent.prototype.getFilterBase = function (filter) {
+        var customFilter = undefined;
+        if (typeof filter === 'object') {
+            customFilter = filter;
+        }
+        if (typeof filter === 'function') {
+            //const object: XObject = this.props.form.getXObject();
+            var object = this.props.form.state.object;
+            // zatial zakomentujeme, aby sa zavolal aj pre XAutoComplete (tam zatial nemame k dispozicii object
+            // (componentDidMount pre XAutoComplete sa vola skor ako componentDidMount pre XFormBase))
+            //if (object) {
+            customFilter = filter(object);
+            //}
+        }
+        return customFilter;
     };
     return XFormComponent;
 }(react_1.Component));

package/lib/components/XFormComponentDT.d.ts

@@ -0,0 +1,30 @@
+import { XFormBase } from "./XFormBase";
+import { Component } from "react";
+import { OperationType } from "./XUtils";
+import { XError } from "./XErrors";
+import { XCustomFilter } from "../serverApi/FindParam";
+import { XTableFieldFilterProp, TableFieldOnChange } from "./XFormDataTable2";
+export interface XFormComponentDTProps {
+    form: XFormBase;
+    entity: string;
+    rowData: any;
+    readOnly?: boolean;
+    onChange?: TableFieldOnChange;
+}
+export declare abstract class XFormComponentDT<P extends XFormComponentDTProps> extends Component<P> {
+    protected constructor(props: P);
+    abstract getField(): string;
+    getValueFromRowData(): any;
+    onValueChangeBase(value: any, onChange?: TableFieldOnChange, assocObjectChange?: OperationType): void;
+    abstract isNotNull(): boolean;
+    isReadOnly(): boolean;
+    validate(): {
+        field: string;
+        xError: XError;
+    } | undefined;
+    validateOnChange(value: any): string | undefined;
+    validateNotNull(value: any): string | undefined;
+    getError(): string | undefined;
+    callOnChangeFromOnBlur(): void;
+    getFilterBase(filter: XTableFieldFilterProp | undefined): XCustomFilter | undefined;
+}

package/lib/components/XFormComponentDT.js

@@ -0,0 +1,119 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XFormComponentDT = void 0;
+var XFormBase_1 = require("./XFormBase");
+var react_1 = require("react");
+var XUtilsCommon_1 = require("../serverApi/XUtilsCommon");
+var XUtils_1 = require("./XUtils");
+var XFormComponentDT = /** @class */ (function (_super) {
+    __extends(XFormComponentDT, _super);
+    function XFormComponentDT(props) {
+        var _this = _super.call(this, props) || this;
+        XFormBase_1.XFormBase.getXRowTechData(props.rowData).xFormComponentDTList.push(_this);
+        return _this;
+    }
+    // ******** read and write from/into this.props.rowData ***********
+    // reads value from this.props.rowData
+    // can be overridden, but this should work for every component
+    XFormComponentDT.prototype.getValueFromRowData = function () {
+        var rowDataValue = null;
+        // test na undefined je tu koli insertu noveho riadku
+        if (this.props.rowData !== undefined && this.props.rowData !== null) {
+            rowDataValue = XUtilsCommon_1.XUtilsCommon.getValueByPath(this.props.rowData, this.getField());
+            //  pre istotu dame na null, null je standard
+            if (rowDataValue === undefined) {
+                rowDataValue = null;
+            }
+        }
+        return rowDataValue;
+    };
+    // writes value into form.state.object
+    XFormComponentDT.prototype.onValueChangeBase = function (value, onChange, assocObjectChange) {
+        var error = this.validateOnChange(value);
+        this.props.form.onTableFieldChange(this.props.rowData, this.getField(), value, error, onChange, assocObjectChange);
+    };
+    XFormComponentDT.prototype.isReadOnly = function () {
+        // tuto do buducna planujeme pridat aj dynamicky readOnly, bude ho treba ukladat do form.state podobne ako sa ukladaju errory do form.state.errorMap
+        return XUtils_1.XUtils.isReadOnly(this.getField(), this.props.readOnly);
+    };
+    // *********** validation support ************
+    // volane po kliknuti na Save
+    // vrati (field, XError) ak nezbehne "field validacia", ak zbehne, vrati undefined
+    XFormComponentDT.prototype.validate = function () {
+        // TODO - FILOZOFICKA OTAZKA - volat validaciu aj ked je field readOnly (this.isReadOnly() === true)? zatial dame ze hej...
+        var value = this.getValueFromRowData();
+        // not null validacia + custom field validacia volana na onChange
+        var errorOnChange = this.validateOnChange(value);
+        // custom field validacia volana na onBlur (focus lost)
+        // TODO - fieldLabel
+        if (errorOnChange) {
+            return { field: this.getField(), xError: { onChange: errorOnChange, fieldLabel: undefined } };
+        }
+        return undefined;
+    };
+    XFormComponentDT.prototype.validateOnChange = function (value) {
+        var error = this.validateNotNull(value);
+        if (error) {
+            return error;
+        }
+        // custom field validacia volana na onChange
+        // TODO
+        return undefined;
+    };
+    XFormComponentDT.prototype.validateNotNull = function (value) {
+        // validacia by mala sediet s metodou getLabel(), kde sa pridava * , preto tu mame aj test !this.isReadOnly() - id fieldy pri inserte nechceme testovat
+        // otazka je ci nevypinat validaciu pre readOnly fieldy vzdy (aj ked napr. readOnly vznikne dynamicky)
+        if (this.isNotNull() && !this.isReadOnly() && value === null) {
+            return "Field is required.";
+        }
+        return undefined;
+    };
+    // vrati error message z rowData.errorMap
+    XFormComponentDT.prototype.getError = function () {
+        var error = XFormBase_1.XFormBase.getXRowTechData(this.props.rowData).errorMap[this.getField()];
+        return error ? XUtils_1.XUtils.getErrorMessage(error) : undefined;
+    };
+    XFormComponentDT.prototype.callOnChangeFromOnBlur = function () {
+        if (this.props.onChange) {
+            var object = this.props.form.getXObject();
+            // developer v onChange nastavi atributy na object-e
+            this.props.onChange({ object: object, tableRow: this.props.rowData, assocObjectChange: undefined });
+            // rovno zavolame form.setState({...}), nech to nemusi robit developer
+            this.props.form.setStateXForm();
+        }
+    };
+    // len pre assoc fieldy sa pouziva, aj to nie pre vsetky
+    XFormComponentDT.prototype.getFilterBase = function (filter) {
+        var customFilter = undefined;
+        if (typeof filter === 'object') {
+            customFilter = filter;
+        }
+        if (typeof filter === 'function') {
+            //const object: XObject = this.props.form.getXObject();
+            var object = this.props.form.state.object;
+            // zatial zakomentujeme, aby sa zavolal aj pre XAutoComplete (tam zatial nemame k dispozicii object
+            // (componentDidMount pre XAutoComplete sa vola skor ako componentDidMount pre XFormBase))
+            //if (object) {
+            customFilter = filter(object, this.props.rowData);
+            //}
+        }
+        return customFilter;
+    };
+    return XFormComponentDT;
+}(react_1.Component));
+exports.XFormComponentDT = XFormComponentDT;