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

package/lib/components/XCheckbox.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { XInput, XInputProps } from "./XInput";
-export declare class XCheckbox extends XInput<XInputProps> {
-    constructor(props: XInputProps);
+export declare class XCheckbox extends XInput<boolean, XInputProps<boolean>> {
+    constructor(props: XInputProps<boolean>);
     getValue(): boolean | null;
     onValueChange(e: any): void;
     render(): JSX.Element;

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);
@@ -125,12 +125,14 @@ var XDropdown = /** @class */ (function (_super) {
     XDropdown.prototype.render = function () {
         // TODO - pridat cez generikum typ objektu v Dropdown-e (ak sa da)
         var options = this.state.options;
-        // TODO - readOnly implementovat
+        // TODO - mozno by nebolo od veci pouzivat InputText ak readOnly === true (chybala by len sipka (rozbalovac)) a dalo by sa copy-paste-ovat
+        // propertiesy na Dropdown-e: readOnly vyseduje, disabled znemoznuje vyber polozky
+        var readOnly = this.isReadOnly();
         // Dropdown setuje do atributu object.assocField asociovany objekt zo zoznamu objektov ktore ziskame podla asociacie
         // appendTo={document.body} appenduje overlay panel na element body - eliminuje "skakanie" formularu na mobile pri kliknuti na dropdown
         return (react_1.default.createElement("div", { className: "field grid" },
             react_1.default.createElement("label", { htmlFor: this.props.assocField, className: "col-fixed", style: this.getLabelStyle() }, this.getLabel()),
-            react_1.default.createElement(dropdown_1.Dropdown, __assign({ appendTo: document.body, id: this.props.assocField, optionLabel: this.props.displayField, value: this.getValue(), options: options, onChange: this.onValueChange }, this.getClassNameTooltip()))));
+            react_1.default.createElement(dropdown_1.Dropdown, __assign({ appendTo: document.body, id: this.props.assocField, optionLabel: this.props.displayField, value: this.getValue(), options: options, onChange: this.onValueChange, readOnly: readOnly, disabled: readOnly }, this.getClassNameTooltip()))));
     };
     return XDropdown;
 }(XFormComponent_1.XFormComponent));

package/lib/components/XExportRowsDialog.js

@@ -52,13 +52,13 @@ var XUtilsConversions_1 = require("./XUtilsConversions");
 var XExportRowsDialog = function (props) {
     var _a;
     var _b = __read((0, react_1.useState)(ExportImportParam_1.ExportType.Csv), 2), exportType = _b[0], setExportType = _b[1];
-    var _c = __read((0, react_1.useState)(false), 2), createHeaderLine = _c[0], setCreateHeaderLine = _c[1];
+    var _c = __read((0, react_1.useState)(true), 2), createHeaderLine = _c[0], setCreateHeaderLine = _c[1];
     var _d = __read((0, react_1.useState)(ExportImportParam_1.CsvSeparator.Semicolon), 2), csvSeparator = _d[0], setCsvSeparator = _d[1];
     var _e = __read((0, react_1.useState)(ExportImportParam_1.CsvDecimalFormat.Comma), 2), decimalFormat = _e[0], setDecimalFormat = _e[1];
     // bez tejto metody by pri opetovnom otvoreni dialogu ponechal povodne hodnoty
     var onShow = function () {
         setExportType(ExportImportParam_1.ExportType.Csv);
-        setCreateHeaderLine(false); // excel hadze hlasky koli prvemu riadku header-ov
+        setCreateHeaderLine(true); // excel hadze hlasky koli prvemu riadku header-ov
         setCsvSeparator(ExportImportParam_1.CsvSeparator.Semicolon);
         setDecimalFormat(ExportImportParam_1.CsvDecimalFormat.Comma);
     };

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,30 @@ 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;
+    formReadOnlyBase(field: string): boolean;
     onClickSave(): Promise<void>;
     onClickCancel(): void;
     validateSave(): boolean;
     validateForm(): XErrorMap;
     fieldValidation(): XErrorMap;
+    formReadOnly(object: XObject, field: string): boolean;
+    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);
     };
@@ -301,6 +345,10 @@ var XFormBase = /** @class */ (function (_super) {
     XFormBase.prototype.addXFormDataTable = function (xFormDataTable) {
         this.xFormDataTableList.push(xFormDataTable);
     };
+    XFormBase.prototype.formReadOnlyBase = function (field) {
+        // TODO - bude this.state.object vzdycky !== undefined?
+        return this.formReadOnly(this.state.object, field);
+    };
     XFormBase.prototype.onClickSave = function () {
         return __awaiter(this, void 0, void 0, function () {
             var isAddRow, object, e_3;
@@ -328,7 +376,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 +410,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 +458,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 +485,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 +497,15 @@ var XFormBase = /** @class */ (function (_super) {
         }
         return xErrorMap;
     };
+    // this method can be overriden in subclass if needed
+    // (the purpose is to put the whole form to read only mode (maybe with exception a few fields))
+    // if returns true for the param "field", then the field is read only, otherwise the property readOnly of the XInput* is processed
+    XFormBase.prototype.formReadOnly = function (object, field) {
+        return false;
+    };
+    // 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 +513,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,25 @@
 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 XReadOnlyProp = boolean | ((object: any) => boolean);
+export type XFilterProp = XCustomFilter | ((object: any) => XCustomFilter | undefined);
+export interface XFormComponentProps<T> {
     form: XFormBase;
     label?: string;
-    readOnly?: boolean;
+    readOnly?: XReadOnlyProp;
     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 +32,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,13 +42,39 @@ 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
-        return XUtils_1.XUtils.isReadOnly(this.getField(), this.props.readOnly);
+        var readOnly;
+        if (!XUtilsCommon_1.XUtilsCommon.isSingleField(this.getField())) {
+            // if the length of field is 2 or more, then readOnly
+            readOnly = true;
+        }
+        // the purpose of formReadOnly is to put the whole form to read only mode,
+        // that's why the formReadOnly has higher prio then property this.props.readOnly
+        else if (this.props.form.formReadOnlyBase(this.getField())) {
+            readOnly = true;
+        }
+        else if (typeof this.props.readOnly === 'boolean') {
+            readOnly = this.props.readOnly;
+        }
+        else if (typeof this.props.readOnly === 'function') {
+            // TODO - tazko povedat ci niekedy bude object === null (asi ano vid metodu getFilterBase)
+            var object = this.props.form.state.object;
+            if (object) {
+                readOnly = this.props.readOnly(this.props.form.getXObject());
+            }
+            else {
+                readOnly = true;
+            }
+        }
+        else {
+            // readOnly is undefined
+            readOnly = false;
+        }
+        return readOnly;
     };
     XFormComponent.prototype.getLabel = function () {
         var _a;
@@ -116,7 +142,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;
+}