d2aura 23.0.0

package/coreui/components/edaManager/components/edaVectorSelect/edaVectorSelect.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import AbstractSelect, { AbstractSelectProps } from "../../../select/abstractSelect";
+import { EdaVector } from "../../../../../api/edaApi";
+interface Props extends AbstractSelectProps<EdaVector> {
+}
+export default class EdaVectorSelect extends AbstractSelect<EdaVector, Props> {
+    constructor(props: Readonly<Props>);
+    renderSelectDialog(): React.ReactNode;
+}
+export {};

package/coreui/components/edaManager/components/edaVectorSelect/edaVectorSelect.js

@@ -0,0 +1,20 @@
+import React from "react";
+import EdaVectorSelectModalDialog from "./edaVectorSelectModalDialog";
+import AbstractSelect from "../../../select/abstractSelect";
+export default class EdaVectorSelect extends AbstractSelect {
+    constructor(props) {
+        super(props);
+        this.state = {
+            ...this.initialState,
+        };
+    }
+    renderSelectDialog() {
+        return (React.createElement(EdaVectorSelectModalDialog, { api: this.props.api, advancedFilterApi: this.props.advancedFilterApi, visible: this.state.selectDialogVisible, onItemsSelected: selectedVectors => {
+                this.props.onItemSelected?.(selectedVectors[0]);
+                this.setState({ selectDialogVisible: false });
+            }, onCancel: () => {
+                this.setState({ selectDialogVisible: false });
+            } }));
+    }
+}
+//# sourceMappingURL=edaVectorSelect.js.map

package/coreui/components/edaManager/components/edaVectorSelect/edaVectorSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edaVectorSelect.js","sourceRoot":"","sources":["../../../../../../../coreui/components/edaManager/components/edaVectorSelect/edaVectorSelect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,0BAA0B,MAAM,8BAA8B,CAAC;AACtE,OAAO,cAAqC,MAAM,gCAAgC,CAAC;AAMnF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,cAAgC;IACzE,YAAY,KAAsB;QAC9B,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,IAAI,CAAC,KAAK,GAAG;YACT,GAAG,IAAI,CAAC,YAAY;SACvB,CAAA;IACL,CAAC;IAED,kBAAkB;QACd,OAAO,CACH,oBAAC,0BAA0B,IACvB,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,EACnB,iBAAiB,EAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAC/C,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,mBAAmB,EACvC,eAAe,EAAE,eAAe,CAAC,EAAE;gBAC/B,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;gBAChD,IAAI,CAAC,QAAQ,CAAC,EAAC,mBAAmB,EAAE,KAAK,EAAC,CAAC,CAAC;YAChD,CAAC,EACD,QAAQ,EAAE,GAAG,EAAE;gBACX,IAAI,CAAC,QAAQ,CAAC,EAAC,mBAAmB,EAAE,KAAK,EAAC,CAAC,CAAC;YAChD,CAAC,GACH,CACL,CAAC;IACN,CAAC;CAEJ","sourcesContent":["import React from \"react\";\r\nimport EdaVectorSelectModalDialog from \"./edaVectorSelectModalDialog\";\r\nimport AbstractSelect, {AbstractSelectProps} from \"../../../select/abstractSelect\";\r\nimport {EdaVector} from \"../../../../../api/edaApi\";\r\n\r\ninterface Props extends AbstractSelectProps<EdaVector> {\r\n}\r\n\r\nexport default class EdaVectorSelect extends AbstractSelect<EdaVector, Props> {\r\n    constructor(props: Readonly<Props>) {\r\n        super(props);\r\n\r\n        this.state = {\r\n            ...this.initialState,\r\n        }\r\n    }\r\n\r\n    renderSelectDialog(): React.ReactNode {\r\n        return (\r\n            <EdaVectorSelectModalDialog\r\n                api={this.props.api}\r\n                advancedFilterApi={this.props.advancedFilterApi}\r\n                visible={this.state.selectDialogVisible}\r\n                onItemsSelected={selectedVectors => {\r\n                    this.props.onItemSelected?.(selectedVectors[0]);\r\n                    this.setState({selectDialogVisible: false});\r\n                }}\r\n                onCancel={() => {\r\n                    this.setState({selectDialogVisible: false});\r\n                }}\r\n            />\r\n        );\r\n    }\r\n\r\n}"]}

package/coreui/components/edaManager/components/edaVectorSelect/edaVectorSelectModalDialog.d.ts

@@ -0,0 +1,13 @@
+import AbstractSelectModalDialog, { AbstractSelectModalDialogProps } from "../../../select/abstractSelectModalDialog";
+import { EdaVector } from "../../../../../api/edaApi";
+import { EntityColumn } from "../../../advancedFilter/advancedFilterColumnDefinitions";
+import { AdvancedFilterListNameEnum } from "../../../advancedFilter/advancedFilterUtils";
+interface Props extends AbstractSelectModalDialogProps<EdaVector> {
+}
+export default class EdaVectorSelectModalDialog extends AbstractSelectModalDialog<EdaVector, Props> {
+    constructor(props: Readonly<Props>);
+    getIdColumnName(): EntityColumn;
+    getTitle(): string;
+    getAdvancedFilterListName(): AdvancedFilterListNameEnum;
+}
+export {};

package/coreui/components/edaManager/components/edaVectorSelect/edaVectorSelectModalDialog.js

@@ -0,0 +1,22 @@
+import AbstractSelectModalDialog from "../../../select/abstractSelectModalDialog";
+import { EntityColumn } from "../../../advancedFilter/advancedFilterColumnDefinitions";
+import { AdvancedFilterListNameEnum } from "../../../advancedFilter/advancedFilterUtils";
+import i18n from "d2core/i18n/i18n";
+export default class EdaVectorSelectModalDialog extends AbstractSelectModalDialog {
+    constructor(props) {
+        super(props);
+        this.state = {
+            ...this.initialState,
+        };
+    }
+    getIdColumnName() {
+        return EntityColumn.ID_VEKTOR;
+    }
+    getTitle() {
+        return i18n("Vector List");
+    }
+    getAdvancedFilterListName() {
+        return AdvancedFilterListNameEnum.EDA_VECTOR_SELECT_LIST;
+    }
+}
+//# sourceMappingURL=edaVectorSelectModalDialog.js.map

package/coreui/components/edaManager/components/edaVectorSelect/edaVectorSelectModalDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edaVectorSelectModalDialog.js","sourceRoot":"","sources":["../../../../../../../coreui/components/edaManager/components/edaVectorSelect/edaVectorSelectModalDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,yBAA2D,MAAM,2CAA2C,CAAC;AAEpH,OAAO,EAAC,YAAY,EAAC,MAAM,yDAAyD,CAAC;AACrF,OAAO,EAAC,0BAA0B,EAAC,MAAM,6CAA6C,CAAC;AACvF,OAAO,IAAI,MAAM,kBAAkB,CAAC;AAKpC,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,yBAA2C;IAC/F,YAAY,KAAsB;QAC9B,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,IAAI,CAAC,KAAK,GAAG;YACT,GAAG,IAAI,CAAC,YAAY;SACvB,CAAA;IACL,CAAC;IAED,eAAe;QACX,OAAO,YAAY,CAAC,SAAS,CAAC;IAClC,CAAC;IAED,QAAQ;QACJ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/B,CAAC;IAED,yBAAyB;QACrB,OAAO,0BAA0B,CAAC,sBAAsB,CAAC;IAC7D,CAAC;CAEJ","sourcesContent":["import AbstractSelectModalDialog, {AbstractSelectModalDialogProps} from \"../../../select/abstractSelectModalDialog\";\r\nimport {EdaVector} from \"../../../../../api/edaApi\";\r\nimport {EntityColumn} from \"../../../advancedFilter/advancedFilterColumnDefinitions\";\r\nimport {AdvancedFilterListNameEnum} from \"../../../advancedFilter/advancedFilterUtils\";\r\nimport i18n from \"d2core/i18n/i18n\";\r\n\r\ninterface Props extends AbstractSelectModalDialogProps<EdaVector> {\r\n}\r\n\r\nexport default class EdaVectorSelectModalDialog extends AbstractSelectModalDialog<EdaVector, Props> {\r\n    constructor(props: Readonly<Props>) {\r\n        super(props);\r\n\r\n        this.state = {\r\n            ...this.initialState,\r\n        }\r\n    }\r\n\r\n    getIdColumnName(): EntityColumn {\r\n        return EntityColumn.ID_VEKTOR;\r\n    }\r\n\r\n    getTitle(): string {\r\n        return i18n(\"Vector List\");\r\n    }\r\n\r\n    getAdvancedFilterListName(): AdvancedFilterListNameEnum {\r\n        return AdvancedFilterListNameEnum.EDA_VECTOR_SELECT_LIST;\r\n    }\r\n\r\n}"]}

package/coreui/components/edaManager/constants.d.ts

@@ -0,0 +1,2 @@
+import { IGlobalAttributes } from "flexlayout-react";
+export declare const EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES: IGlobalAttributes;

package/coreui/components/edaManager/constants.js

@@ -0,0 +1,11 @@
+export const EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES = {
+    splitterSize: 4,
+    tabSetEnableMaximize: false,
+    tabSetHeaderHeight: 32,
+    tabSetTabStripHeight: 32,
+    tabEnableClose: false,
+    tabEnableRename: false,
+    tabEnableDrag: false,
+    tabSetEnableDrag: false,
+};
+//# sourceMappingURL=constants.js.map

package/coreui/components/edaManager/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../coreui/components/edaManager/constants.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,0CAA0C,GAAsB;IACzE,YAAY,EAAE,CAAC;IACf,oBAAoB,EAAE,KAAK;IAC3B,kBAAkB,EAAE,EAAE;IACtB,oBAAoB,EAAE,EAAE;IACxB,cAAc,EAAE,KAAK;IACrB,eAAe,EAAE,KAAK;IACtB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,KAAK;CAC1B,CAAA","sourcesContent":["import {IGlobalAttributes} from \"flexlayout-react\";\r\n\r\nexport const EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES: IGlobalAttributes = {\r\n    splitterSize: 4,\r\n    tabSetEnableMaximize: false,\r\n    tabSetHeaderHeight: 32,\r\n    tabSetTabStripHeight: 32,\r\n    tabEnableClose: false,\r\n    tabEnableRename: false,\r\n    tabEnableDrag: false,\r\n    tabSetEnableDrag: false,\r\n}"]}

package/coreui/components/edaManager/panel/edaManagerPanel.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import EdaManagerAbstractPanel, { EdaManagerAbstractPanelProps, EdaManagerAbstractPanelState } from "../abstract/edaManagerAbstractPanel";
+import * as FlexLayout from "flexlayout-react";
+interface Props extends EdaManagerAbstractPanelProps {
+}
+interface State extends EdaManagerAbstractPanelState {
+}
+export default class EdaManagerPanel extends EdaManagerAbstractPanel<Props, State> {
+    constructor(props: Readonly<Props>);
+    protected flexLayoutFactory(node: FlexLayout.TabNode): React.ReactNode;
+    getFilterNameToSave(): string;
+}
+export {};

package/coreui/components/edaManager/panel/edaManagerPanel.js

@@ -0,0 +1,32 @@
+import React from "react";
+import EdaManagerAbstractPanel from "../abstract/edaManagerAbstractPanel";
+import * as FlexLayout from "flexlayout-react";
+import EdaManagerVectorList from "../components/edaManagerVectorList";
+import { edaManagerInitialLayoutModel } from "./initialLayout";
+export default class EdaManagerPanel extends EdaManagerAbstractPanel {
+    constructor(props) {
+        super(props);
+        this.state = {
+            layoutModel: FlexLayout.Model.fromJson(edaManagerInitialLayoutModel()),
+            ...this.initialState,
+        };
+    }
+    flexLayoutFactory(node) {
+        const component = node.getComponent();
+        if (component === "vectors") {
+            return (React.createElement(EdaManagerVectorList, { edaApi: this.props.edaApi, advancedFilterApi: this.props.advancedFilterApi, currentVectors: this.state.currentFilter.currentVectors, onChange: () => {
+                    this.setState({ currentFilter: this.state.currentFilter }, () => {
+                        this.saveFilter();
+                    });
+                    if (this.state.currentFilter.timePanelConfiguration.autoRefresh) {
+                        this.onLoadVectors();
+                    }
+                } }));
+        }
+        return super.flexLayoutFactory(node);
+    }
+    getFilterNameToSave() {
+        return "eda-manager-current-filter";
+    }
+}
+//# sourceMappingURL=edaManagerPanel.js.map

package/coreui/components/edaManager/panel/edaManagerPanel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edaManagerPanel.js","sourceRoot":"","sources":["../../../../../../coreui/components/edaManager/panel/edaManagerPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,uBAGN,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,oBAAoB,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAC,4BAA4B,EAAC,MAAM,iBAAiB,CAAC;AAQ7D,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,uBAAqC;IAC9E,YAAY,KAAsB;QAC9B,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,IAAI,CAAC,KAAK,GAAG;YACT,WAAW,EAAE,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,4BAA4B,EAAE,CAAC;YACtE,GAAG,IAAI,CAAC,YAAY;SACvB,CAAA;IACL,CAAC;IAES,iBAAiB,CAAC,IAAwB;QAChD,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACtC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO,CACH,oBAAC,oBAAoB,IACjB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EACzB,iBAAiB,EAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAC/C,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,cAAc,EACvD,QAAQ,EAAE,GAAG,EAAE;oBACX,IAAI,CAAC,QAAQ,CAAC,EAAC,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa,EAAC,EAAE,GAAG,EAAE;wBAC1D,IAAI,CAAC,UAAU,EAAE,CAAC;oBACtB,CAAC,CAAC,CAAC;oBAEH,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,sBAAsB,CAAC,WAAW,EAAE,CAAC;wBAC9D,IAAI,CAAC,aAAa,EAAE,CAAC;oBACzB,CAAC;gBACL,CAAC,GACH,CACL,CAAA;QACL,CAAC;QACD,OAAO,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,mBAAmB;QACf,OAAO,4BAA4B,CAAC;IACxC,CAAC;CAEJ","sourcesContent":["import React from \"react\";\r\nimport EdaManagerAbstractPanel, {\r\n    EdaManagerAbstractPanelProps,\r\n    EdaManagerAbstractPanelState\r\n} from \"../abstract/edaManagerAbstractPanel\";\r\nimport * as FlexLayout from \"flexlayout-react\";\r\nimport EdaManagerVectorList from \"../components/edaManagerVectorList\";\r\nimport {edaManagerInitialLayoutModel} from \"./initialLayout\";\r\n\r\ninterface Props extends EdaManagerAbstractPanelProps {\r\n}\r\n\r\ninterface State extends EdaManagerAbstractPanelState {\r\n}\r\n\r\nexport default class EdaManagerPanel extends EdaManagerAbstractPanel<Props, State> {\r\n    constructor(props: Readonly<Props>) {\r\n        super(props);\r\n\r\n        this.state = {\r\n            layoutModel: FlexLayout.Model.fromJson(edaManagerInitialLayoutModel()),\r\n            ...this.initialState,\r\n        }\r\n    }\r\n\r\n    protected flexLayoutFactory(node: FlexLayout.TabNode): React.ReactNode {\r\n        const component = node.getComponent();\r\n        if (component === \"vectors\") {\r\n            return (\r\n                <EdaManagerVectorList\r\n                    edaApi={this.props.edaApi}\r\n                    advancedFilterApi={this.props.advancedFilterApi}\r\n                    currentVectors={this.state.currentFilter.currentVectors}\r\n                    onChange={() => {\r\n                        this.setState({currentFilter: this.state.currentFilter}, () => {\r\n                            this.saveFilter();\r\n                        });\r\n\r\n                        if (this.state.currentFilter.timePanelConfiguration.autoRefresh) {\r\n                            this.onLoadVectors();\r\n                        }\r\n                    }}\r\n                />\r\n            )\r\n        }\r\n        return super.flexLayoutFactory(node);\r\n    }\r\n\r\n    getFilterNameToSave(): string {\r\n        return \"eda-manager-current-filter\";\r\n    }\r\n\r\n}"]}

package/coreui/components/edaManager/panel/initialLayout.d.ts

@@ -0,0 +1,2 @@
+import * as FlexLayout from "flexlayout-react";
+export declare function edaManagerInitialLayoutModel(): FlexLayout.IJsonModel;

package/coreui/components/edaManager/panel/initialLayout.js

@@ -0,0 +1,39 @@
+import i18n from "d2core/i18n/i18n";
+import { EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES } from "../constants";
+export function edaManagerInitialLayoutModel() {
+    return {
+        global: EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES,
+        borders: [{
+                type: "border",
+                location: "left",
+                size: 320,
+                selected: 0,
+                children: [
+                    {
+                        type: "tab",
+                        name: i18n("Vectors"),
+                        component: "vectors",
+                    },
+                ]
+            }],
+        layout: {
+            type: "row",
+            children: [{
+                    type: "tabset",
+                    children: [
+                        {
+                            type: "tab",
+                            name: i18n("Chart"),
+                            component: "chart",
+                        },
+                        {
+                            type: "tab",
+                            name: i18n("Table"),
+                            component: "table",
+                        },
+                    ]
+                }]
+        }
+    };
+}
+//# sourceMappingURL=initialLayout.js.map

package/coreui/components/edaManager/panel/initialLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialLayout.js","sourceRoot":"","sources":["../../../../../../coreui/components/edaManager/panel/initialLayout.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,kBAAkB,CAAC;AACpC,OAAO,EAAC,0CAA0C,EAAC,MAAM,cAAc,CAAC;AAExE,MAAM,UAAU,4BAA4B;IACxC,OAAO;QACH,MAAM,EAAE,0CAA0C;QAClD,OAAO,EAAE,CAAC;gBACN,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,MAAM;gBAChB,IAAI,EAAE,GAAG;gBACT,QAAQ,EAAE,CAAC;gBACX,QAAQ,EAAE;oBACN;wBACI,IAAI,EAAE,KAAK;wBACX,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACrB,SAAS,EAAE,SAAS;qBACvB;iBAWJ;aACJ,CAAC;QACF,MAAM,EAAE;YACJ,IAAI,EAAE,KAAK;YACX,QAAQ,EAAE,CAAC;oBACP,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE;wBACN;4BACI,IAAI,EAAE,KAAK;4BACX,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC;4BACnB,SAAS,EAAE,OAAO;yBAErB;wBACD;4BACI,IAAI,EAAE,KAAK;4BACX,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC;4BACnB,SAAS,EAAE,OAAO;yBAErB;qBACJ;iBACJ,CAAC;SACL;KACJ,CAAA;AACL,CAAC","sourcesContent":["import * as FlexLayout from \"flexlayout-react\";\r\nimport i18n from \"d2core/i18n/i18n\";\r\nimport {EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES} from \"../constants\";\r\n\r\nexport function edaManagerInitialLayoutModel(): FlexLayout.IJsonModel {\r\n    return {\r\n        global: EDA_MANAGER_LAYOUT_MODEL_GLOBAL_ATTRIBUTES,\r\n        borders: [{\r\n            type: \"border\",\r\n            location: \"left\",\r\n            size: 320,\r\n            selected: 0,\r\n            children: [\r\n                {\r\n                    type: \"tab\",\r\n                    name: i18n(\"Vectors\"),\r\n                    component: \"vectors\",\r\n                },\r\n                // {\r\n                //     type: \"tab\",\r\n                //     name: i18n(\"Groups\"),\r\n                //     component: \"groups\",\r\n                // },\r\n                // {\r\n                //     type: \"tab\",\r\n                //     name: i18n(\"Scenarios\"),\r\n                //     component: \"scenarios\",\r\n                // }\r\n            ]\r\n        }],\r\n        layout: {\r\n            type: \"row\",\r\n            children: [{\r\n                type: \"tabset\",\r\n                children: [\r\n                    {\r\n                        type: \"tab\",\r\n                        name: i18n(\"Chart\"),\r\n                        component: \"chart\",\r\n                        // enableDrag: true,\r\n                    },\r\n                    {\r\n                        type: \"tab\",\r\n                        name: i18n(\"Table\"),\r\n                        component: \"table\",\r\n                        // enableDrag: true,\r\n                    },\r\n                ]\r\n            }]\r\n        }\r\n    }\r\n}\r\n"]}

package/coreui/components/editor/abstractEntityConfigPanel.d.ts

@@ -0,0 +1,82 @@
+import React from "react";
+import { InputRef } from "antd";
+import AbstractEntityApi from "../../../api/abstractEntityApi";
+import { AbstractBreadcrumbItem } from "../../abstractListPanel";
+import AuditableEntity from "../../../api/types/auditableEntity";
+import { AccessRight } from "../../../api/types/accessRight";
+import { ErrorCode } from "../../../api/validation/abstractEntityValidationUtils";
+interface GeneralConfigItemParams {
+    hidden?: boolean;
+    notRequired?: boolean;
+    disabled?: boolean;
+}
+export interface EntityValidationContext {
+    errors: ErrorCode[];
+}
+export interface EntityConfigPanelProperties<T extends AuditableEntity> {
+    api: AbstractEntityApi<T>;
+    selectedEntity?: T;
+    hidePrevNextButton?: boolean;
+    hideConfigHeader?: boolean;
+    hideConfigFooter?: boolean;
+    historyMode?: boolean;
+    fieldsToHighlight?: string[];
+    breadcrumbPath?: AbstractBreadcrumbItem[];
+    onClose?(): void;
+    onNextRecord?(): void;
+    onPrevRecord?(): void;
+    onSave?(savedEntity: T): void;
+}
+export interface EntityConfigPanelState<T extends AuditableEntity> {
+    originalEntity?: T;
+    editedEntity: T;
+    editedEntityValidationContext: EntityValidationContext;
+    validationIsRunning: boolean;
+    savingIsRunning: boolean;
+    validateOnChange: boolean;
+    waitingForLockResponse: boolean;
+    savingIsStarting: boolean;
+    nameSameAsCode: boolean;
+}
+export default abstract class AbstractEntityConfigPanel<P extends EntityConfigPanelProperties<E>, S extends EntityConfigPanelState<E>, E extends AuditableEntity = S extends EntityConfigPanelState<infer T> ? T : never> extends React.Component<P, S> {
+    protected codeInput: InputRef | null;
+    protected constructor(props: Readonly<P>);
+    protected initialState: EntityConfigPanelState<E>;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: Readonly<P>, prevState: Readonly<S>): void;
+    componentWillUnmount(): void;
+    getOriginal(): E | undefined;
+    getEdited(): E;
+    revertChanges(): void;
+    abstract validateObject(): ErrorCode[];
+    private validate;
+    save(isCosmeticChange?: boolean): Promise<E | undefined>;
+    protected onSave(): Promise<void>;
+    protected afterSave(): void;
+    updateEditedObject(): void;
+    onChangeEditContext(_original?: E, _edited?: E, _editedEntityValidationContext?: EntityValidationContext): void;
+    updateData(originalEntity?: E, editedEntity?: E, editedEntityValidationContext?: EntityValidationContext, callback?: () => void): void;
+    renderConfigHeader(hidePrevNextButton?: boolean): React.JSX.Element;
+    protected onEditStart(): Promise<void>;
+    focusFirstField(): void;
+    isEditDisabled(): boolean;
+    protected getCodeMaxLength(): number;
+    protected getNameMaxLength(): number;
+    protected renderCodeSuffix(): React.ReactNode | undefined;
+    protected handleCodeChange(value: string): void;
+    protected renderGeneralConfigItems(codeConfig?: GeneralConfigItemParams, nameConfig?: GeneralConfigItemParams, hideDivider?: boolean): React.JSX.Element;
+    protected renderNoteFormItem(): React.JSX.Element;
+    protected isNewEntity(): boolean;
+    protected isEditMode(): boolean | undefined;
+    protected getAccessRightForEntity(): Promise<{
+        accessRight: AccessRight;
+        message: string;
+    }>;
+    protected getFieldsToOmitForCompare(): string[];
+    protected isEntityModified(): boolean;
+    startEdit(): Promise<boolean>;
+    renderConfigFooter(): React.JSX.Element;
+    abstract renderConfigForm(): React.ReactNode;
+    render(): React.JSX.Element;
+}
+export {};

package/coreui/components/editor/abstractEntityConfigPanel.js

@@ -0,0 +1,307 @@
+import React from "react";
+import { cloneDeep, isEqual, omit } from "lodash";
+import { Button, Col, Divider, Form, Input, Row, Switch } from "antd";
+import i18n from "d2core/i18n/i18n";
+import { CloseCircleOutlined, EditOutlined, SaveOutlined } from "@ant-design/icons";
+import { UndoIcon } from "d2coreui/components/icons/undoIcon";
+import DetailHeaderPanel from "../grid/detailHeaderPanel";
+import { EntityColumn } from "../advancedFilter/advancedFilterColumnDefinitions";
+import TextArea from "antd/es/input/TextArea";
+import { AccessRight } from "../../../api/types/accessRight";
+import { ModalDialog } from "d2coreui/components/modal/modalDialog";
+import { AbstractEntityValidationErrorEnum, getErrorInfo } from "../../../api/validation/abstractEntityValidationUtils";
+import { DbBoolean } from "../../../api/types/dbBoolean";
+export default class AbstractEntityConfigPanel extends React.Component {
+    constructor(props) {
+        super(props);
+        this.codeInput = null;
+        this.initialState = {
+            editedEntity: this.props.selectedEntity,
+            editedEntityValidationContext: { errors: [] },
+            validationIsRunning: false,
+            savingIsRunning: false,
+            validateOnChange: false,
+            waitingForLockResponse: false,
+            savingIsStarting: false,
+            nameSameAsCode: true,
+        };
+        this.updateEditedObject = this.updateEditedObject.bind(this);
+        this.renderNoteFormItem = this.renderNoteFormItem.bind(this);
+    }
+    componentDidMount() {
+        this.updateEditedObject();
+    }
+    componentDidUpdate(prevProps, prevState) {
+        if (!isEqual(prevProps.selectedEntity, this.props.selectedEntity)) {
+            if (prevState.editedEntity?.locked) {
+                this.props.api.unlockEntity(prevState.editedEntity);
+            }
+            this.updateData(this.props.selectedEntity, cloneDeep(this.props.selectedEntity), { errors: [] }, () => {
+                this.setState({ validateOnChange: false, nameSameAsCode: this.isNewEntity() });
+            });
+        }
+    }
+    componentWillUnmount() {
+        if (this.state.editedEntity?.locked) {
+            this.props.api.unlockEntity(this.state.editedEntity);
+        }
+    }
+    getOriginal() {
+        return this.state.originalEntity;
+    }
+    getEdited() {
+        return this.state.editedEntity;
+    }
+    revertChanges() {
+        if (this.state.originalEntity && !isEqual(this.state.editedEntity, this.state.originalEntity)) {
+            this.updateData(undefined, cloneDeep(this.state.originalEntity), undefined, () => {
+                const editedEntityValidationContext = this.state.editedEntityValidationContext;
+                editedEntityValidationContext.errors = [];
+                this.setState({ editedEntityValidationContext: editedEntityValidationContext });
+            });
+        }
+    }
+    async validate() {
+        const isNewEntity = this.state.editedEntity.id < 0 || this.state.editedEntity.id === undefined;
+        this.setState({ validationIsRunning: true });
+        const editedEntityValidationContext = this.state.editedEntityValidationContext;
+        editedEntityValidationContext.errors = this.validateObject();
+        const code = this.state.editedEntity.code;
+        if (isNewEntity && code) {
+            const codeExists = await this.props.api.codeExists(code);
+            if (codeExists) {
+                if (!editedEntityValidationContext.errors.includes(AbstractEntityValidationErrorEnum.CODE_DUPLICATE)) {
+                    editedEntityValidationContext.errors.push(AbstractEntityValidationErrorEnum.CODE_DUPLICATE);
+                }
+            }
+            else {
+                const index = editedEntityValidationContext.errors.findIndex(value => value === AbstractEntityValidationErrorEnum.CODE_DUPLICATE);
+                if (index >= 0) {
+                    editedEntityValidationContext.errors.splice(index, 1);
+                }
+            }
+        }
+        this.setState({
+            editedEntityValidationContext: editedEntityValidationContext,
+            validateOnChange: true,
+            validationIsRunning: false,
+        });
+    }
+    ;
+    async save(isCosmeticChange) {
+        await this.validate();
+        const errors = this.state.editedEntityValidationContext.errors;
+        let savedEntity = undefined;
+        if (errors.length === 0 && this.state.originalEntity && !isEqual(this.state.editedEntity, this.state.originalEntity)) {
+            this.setState({ savingIsRunning: true });
+            savedEntity = await this.props.api.saveEntity(this.state.editedEntity, isCosmeticChange);
+            this.setState({ savingIsRunning: false });
+            if (savedEntity) {
+                this.updateData(savedEntity, cloneDeep(savedEntity), { errors: [] });
+                this.props.onSave?.(savedEntity);
+            }
+        }
+        this.afterSave();
+        return savedEntity;
+    }
+    async onSave() {
+        await this.save();
+    }
+    afterSave() {
+    }
+    updateEditedObject() {
+        if (this.state.validateOnChange) {
+            this.validate();
+        }
+        this.updateData(undefined, this.state.editedEntity, this.state.editedEntityValidationContext);
+    }
+    onChangeEditContext(_original, _edited, _editedEntityValidationContext) {
+    }
+    updateData(originalEntity, editedEntity, editedEntityValidationContext, callback) {
+        const newState = {};
+        if (originalEntity) {
+            newState.originalEntity = originalEntity;
+        }
+        if (editedEntity) {
+            newState.editedEntity = editedEntity;
+        }
+        if (editedEntityValidationContext) {
+            newState.editedEntityValidationContext = editedEntityValidationContext;
+        }
+        this.setState(newState, () => {
+            this.onChangeEditContext(originalEntity, editedEntity, editedEntityValidationContext);
+            callback?.();
+        });
+    }
+    renderConfigHeader(hidePrevNextButton) {
+        return (React.createElement(DetailHeaderPanel, { hidePrevNextButton: hidePrevNextButton, code: this.state.editedEntity?.code, onPrevRecord: this.props.onPrevRecord, onNextRecord: this.props.onNextRecord, onClose: this.props.onClose }));
+    }
+    async onEditStart() {
+        this.focusFirstField();
+    }
+    focusFirstField() {
+        if (this.props.selectedEntity?.id === undefined || this.props.selectedEntity?.id === null) {
+            this.codeInput?.focus();
+        }
+    }
+    isEditDisabled() {
+        const entityExists = !!this.state.originalEntity;
+        const isNewEntity = this.state.editedEntity.id < 0 || this.state.editedEntity.id === undefined;
+        const isSaveMode = entityExists && (isNewEntity || this.state.editedEntity.locked);
+        return !isSaveMode;
+    }
+    getCodeMaxLength() {
+        return 64;
+    }
+    getNameMaxLength() {
+        return 256;
+    }
+    renderCodeSuffix() {
+        return undefined;
+    }
+    handleCodeChange(value) {
+        const entity = this.state.editedEntity;
+        entity.code = value;
+        if (this.state.nameSameAsCode) {
+            entity.name = value;
+        }
+        this.updateEditedObject();
+    }
+    renderGeneralConfigItems(codeConfig, nameConfig, hideDivider) {
+        const entity = this.state.editedEntity;
+        const errors = this.state.editedEntityValidationContext.errors;
+        const fieldsToHighlight = this.props.fieldsToHighlight;
+        const [codeValidateStatus, codeErrorMessage] = getErrorInfo([AbstractEntityValidationErrorEnum.CODE_REQUIRED, AbstractEntityValidationErrorEnum.CODE_DUPLICATE], errors);
+        const [nameValidateStatus, nameErrorMessage] = getErrorInfo([AbstractEntityValidationErrorEnum.NAME_REQUIRED], errors);
+        return (React.createElement(Form, { className: "record-config-form", layout: "horizontal", labelCol: { sm: 24, md: 24, lg: 24, xl: 24, xxl: 24 } },
+            React.createElement(Row, { gutter: 8 },
+                React.createElement(Col, { span: 6 },
+                    React.createElement(Form.Item, { label: i18n("ID") },
+                        React.createElement(Input, { disabled: true, value: entity.id }))),
+                !codeConfig?.hidden &&
+                    React.createElement(Col, { span: 18 },
+                        React.createElement(Form.Item, { label: i18n("Code"), validateStatus: fieldsToHighlight?.includes(EntityColumn.CODE) ? "warning" : codeValidateStatus, help: codeErrorMessage, required: !codeConfig?.notRequired },
+                            React.createElement(Input, { disabled: entity.id !== undefined || this.isEditDisabled() || codeConfig?.disabled, ref: (input) => {
+                                    this.codeInput = input;
+                                }, value: entity.code ?? undefined, onChange: e => {
+                                    this.handleCodeChange(e.target.value);
+                                }, suffix: this.renderCodeSuffix(), maxLength: this.getCodeMaxLength(), showCount: true })))),
+            !nameConfig?.hidden &&
+                React.createElement(Form.Item, { className: "form-item-full-width-label", label: React.createElement("div", { style: {
+                            width: "100%",
+                            display: "flex",
+                            justifyContent: "space-between",
+                            alignItems: "baseline",
+                        } },
+                        React.createElement("span", null, i18n("Name")),
+                        this.isNewEntity() &&
+                            React.createElement("span", { style: { display: "flex" } },
+                                React.createElement(Switch, { style: { marginRight: 4 }, size: "small", checked: this.state.nameSameAsCode, onChange: checked => {
+                                        this.setState({ nameSameAsCode: checked });
+                                        if (checked) {
+                                            entity.name = entity.code;
+                                            this.updateEditedObject();
+                                        }
+                                    } }),
+                                i18n("Same As Code"))), validateStatus: fieldsToHighlight?.includes(EntityColumn.NAME) ? "warning" : nameValidateStatus, help: nameErrorMessage, required: !nameConfig?.notRequired },
+                    React.createElement(Input, { value: entity.name ?? undefined, disabled: this.isEditDisabled() || nameConfig?.disabled || this.state.nameSameAsCode, onChange: e => {
+                            entity.name = e.target.value;
+                            this.updateEditedObject();
+                        }, maxLength: this.getNameMaxLength() })),
+            !hideDivider && React.createElement(Divider, { className: "compact-divider" })));
+    }
+    renderNoteFormItem() {
+        const entity = this.state.editedEntity;
+        const fieldsToHighlight = this.props.fieldsToHighlight;
+        return (React.createElement(Form.Item, { label: i18n("Note"), validateStatus: fieldsToHighlight?.includes(EntityColumn.NOTE) ? "warning" : undefined },
+            React.createElement(TextArea, { disabled: this.isEditDisabled(), value: entity.note ?? undefined, onChange: event => {
+                    entity.note = event.target.value;
+                    this.updateEditedObject();
+                } })));
+    }
+    isNewEntity() {
+        return !this.state.editedEntity?.id;
+    }
+    isEditMode() {
+        return this.state.originalEntity && !this.isNewEntity() && !this.state.editedEntity.locked;
+    }
+    async getAccessRightForEntity() {
+        return {
+            accessRight: AccessRight.WRITE,
+            message: "",
+        };
+    }
+    getFieldsToOmitForCompare() {
+        return ["locked"];
+    }
+    isEntityModified() {
+        return !isEqual(omit(cloneDeep(this.state.editedEntity), this.getFieldsToOmitForCompare()), omit(cloneDeep(this.state.originalEntity), this.getFieldsToOmitForCompare()));
+    }
+    async startEdit() {
+        this.setState({ savingIsStarting: true });
+        await this.onEditStart();
+        const accessRightResult = await this.getAccessRightForEntity();
+        this.setState({ savingIsStarting: false });
+        if (accessRightResult.accessRight !== AccessRight.WRITE) {
+            ModalDialog.error({
+                mode: "OK",
+                title: i18n("Edit is not allowed"),
+                content: accessRightResult.message,
+                okText: i18n("Cancel")
+            });
+            return false;
+        }
+        else {
+            this.setState({ waitingForLockResponse: true, nameSameAsCode: false });
+            const isOk = await this.props.api.lockEntity(this.state.editedEntity);
+            this.setState({ waitingForLockResponse: false });
+            if (isOk) {
+                this.updateEditedObject();
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+    renderConfigFooter() {
+        const entityExists = !!this.state.originalEntity;
+        const isNewEntity = this.isNewEntity();
+        const isEditMode = this.isEditMode();
+        const isSaveMode = entityExists && (isNewEntity || this.state.editedEntity.locked);
+        const isEntityModified = entityExists && this.isEntityModified();
+        return (React.createElement("div", { style: { padding: 8 } },
+            React.createElement(Button.Group, { style: { width: "100%" } },
+                React.createElement(Button, { disabled: !entityExists || (isSaveMode ? !isEntityModified : !isEditMode) || this.state.editedEntityValidationContext.errors.length !== 0 || this.state.validationIsRunning, block: true, loading: this.state.waitingForLockResponse || this.state.savingIsStarting || this.state.savingIsRunning, type: "primary", icon: isSaveMode ? React.createElement(SaveOutlined, null) : React.createElement(EditOutlined, null), onClick: async () => {
+                        if (isSaveMode) {
+                            await this.onSave();
+                        }
+                        else if (isEditMode) {
+                            await this.startEdit();
+                        }
+                    } }, isSaveMode ? i18n("Save") : i18n("Edit")),
+                React.createElement(Button, { disabled: !entityExists || !isSaveMode, block: true, danger: true, icon: (isEntityModified && !isNewEntity) ? React.createElement(UndoIcon, null) : React.createElement(CloseCircleOutlined, null), onClick: async () => {
+                        if (isNewEntity) {
+                            this.props.onClose?.();
+                        }
+                        else if (isSaveMode) {
+                            if (this.state.editedEntity.locked) {
+                                await this.props.api.unlockEntity(this.state.editedEntity);
+                            }
+                            this.revertChanges();
+                        }
+                    } }, (isEntityModified && !isNewEntity) ? i18n("Revert Changes") : i18n("Cancel")))));
+    }
+    render() {
+        const entity = this.state.editedEntity;
+        const { hideConfigHeader, hideConfigFooter, historyMode } = this.props;
+        return (React.createElement("div", { style: { display: "flex", flexDirection: "column", overflow: "hidden", width: "100%", height: "100%" } },
+            !hideConfigHeader && !historyMode && this.renderConfigHeader(entity?.id === undefined || this.props.hidePrevNextButton),
+            React.createElement("div", { style: { flex: "1 1 auto", overflow: "hidden" } },
+                React.createElement("div", { style: { height: `calc(100% - ${hideConfigFooter ? 0 : 48}px)` } },
+                    React.createElement("div", { style: { height: "100%", overflow: "auto" } },
+                        React.createElement("div", { style: { margin: "0px 12px 16px" } }, entity && this.renderConfigForm()))),
+                !hideConfigFooter && !historyMode && entity?.ano_platny === DbBoolean.TRUE && this.renderConfigFooter())));
+    }
+}
+//# sourceMappingURL=abstractEntityConfigPanel.js.map