@reltio/components 1.4.1819 → 1.4.1820

package/esm/features/crosswalks/hooks/useModifiedEntity.test.js

@@ -0,0 +1,497 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { renderHook, act } from '@testing-library/react-hooks';
+import * as useAttributesActionsImport from './useAttributeActions';
+import { useModifiedEntity } from './useModifiedEntity';
+describe('useModifiedEntity', function () {
+    var attributeActions = {
+        pinAttribute: jest.fn(),
+        deleteAttribute: jest.fn(),
+        ignoreAttribute: jest.fn(),
+        updateAttribute: jest.fn(),
+        createAttribute: jest.fn()
+    };
+    var useAttributeActionsMock = jest
+        .spyOn(useAttributesActionsImport, 'useAttributeActions')
+        .mockReturnValue(attributeActions);
+    var entity = {
+        uri: 'entities/1',
+        type: 'configuration/entityTypes/HCP',
+        attributes: {
+            Simple: [
+                {
+                    uri: 'entities/1/attributes/Simple/1',
+                    value: 'simple value'
+                }
+            ],
+            Nested: [
+                {
+                    uri: 'entities/1/attributes/Nested/1',
+                    value: {
+                        SubNested: [
+                            {
+                                uri: 'entities/1/attributes/Nested/1/SubNested/1',
+                                value: 'subnested value'
+                            }
+                        ]
+                    }
+                }
+            ],
+            Reference: [
+                {
+                    uri: 'entities/1/attributes/Reference/1',
+                    refRelation: {
+                        uri: 'relations/1',
+                        crosswalks: [
+                            {
+                                uri: 'relations/1/crosswalks/1',
+                                type: 'configuration/sources/AHA',
+                                value: 'cw3',
+                                attributeURIs: ['entities/1/attributes/Reference/1/RefSimple/1']
+                            }
+                        ]
+                    },
+                    value: {
+                        RefSimple: [
+                            {
+                                uri: 'entities/1/attributes/Reference/1/RefSimple/1',
+                                value: 'ref simple value'
+                            }
+                        ]
+                    }
+                }
+            ]
+        },
+        crosswalks: [
+            {
+                uri: 'entities/1/crosswalks/1',
+                type: 'configuration/sources/Reltio',
+                value: 'cw1',
+                attributes: ['entities/1/attributes/Simple/1']
+            },
+            {
+                uri: 'entities/1/crosswalks/2',
+                type: 'configuration/sources/FB',
+                value: 'cw2',
+                attributes: ['entities/1/attributes/Nested/1', 'entities/1/attributes/Nested/1/SubNested/1']
+            }
+        ]
+    };
+    var initCrosswalksMap = {
+        entity: {
+            'entities/1/attributes/Simple/1': [entity.crosswalks[0]],
+            'entities/1/attributes/Nested/1': [entity.crosswalks[1]],
+            'entities/1/attributes/Nested/1/SubNested/1': [entity.crosswalks[1]]
+        },
+        relation: {
+            'entities/1/attributes/Reference/1/RefSimple/1': [entity.attributes.Reference[0].refRelation.crosswalks[0]]
+        }
+    };
+    var initialProps = {
+        entity: entity,
+        onModify: jest.fn(),
+        onError: jest.fn(),
+        onLoad: jest.fn()
+    };
+    var getModifiedEntity = function () {
+        var _a = renderHook(useModifiedEntity, { initialProps: initialProps }), result = _a.result, rerender = _a.rerender;
+        return __assign({ result: result, rerender: rerender }, result.current);
+    };
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should use attribute actions correctly', function () {
+        getModifiedEntity();
+        var _a = useAttributeActionsMock.mock.calls[0][0], onSuccess = _a.onSuccess, onError = _a.onError, onLoad = _a.onLoad;
+        expect(onLoad).toBe(initialProps.onLoad);
+        expect(onSuccess).toBe(initialProps.onModify);
+        var error = new Error();
+        onError === null || onError === void 0 ? void 0 : onError(error);
+        expect(initialProps.onError).toBeCalledWith(error);
+    });
+    it('should return unmodified entity on first render', function () {
+        var modifiedEntity = getModifiedEntity().modifiedEntity;
+        expect(modifiedEntity).toBe(entity);
+    });
+    it('should return correct crosswalks map on first render', function () {
+        var crosswalksMap = getModifiedEntity().crosswalksMap;
+        expect(crosswalksMap).toEqual(initCrosswalksMap);
+    });
+    it('should return correct pin handler', function () {
+        var onPinAttribute = getModifiedEntity().onPinAttribute;
+        expect(onPinAttribute).toBe(attributeActions.pinAttribute);
+    });
+    it('should return correct ignore handler', function () {
+        var onIgnoreAttribute = getModifiedEntity().onIgnoreAttribute;
+        expect(onIgnoreAttribute).toBe(attributeActions.ignoreAttribute);
+    });
+    it('should return correct add handler for simple attribute', function () {
+        var _a;
+        var _b;
+        var _c = getModifiedEntity(), onAddAttribute = _c.onAddAttribute, result = _c.result;
+        var crosswalk = {
+            uri: 'entities/1/crosswalks/1',
+            type: 'configuration/sources/Reltio',
+            value: 'cw1',
+            attributes: ['entities/1/attributes/Simple/1'],
+            ownerType: 'entity'
+        };
+        act(function () {
+            onAddAttribute({
+                attributeType: {
+                    uri: 'configuration/entityTypes/HCP/attributes/Simple',
+                    type: 'Simple',
+                    label: 'Simple',
+                    name: 'Simple'
+                },
+                parentUri: 'entities/1',
+                crosswalk: crosswalk,
+                index: 1
+            });
+        });
+        expect(result.current.modifiedEntity).toEqual(__assign(__assign({}, entity), { attributes: __assign(__assign({}, entity.attributes), { Simple: [
+                    {
+                        uri: 'entities/1/attributes/Simple/1',
+                        value: 'simple value'
+                    },
+                    {
+                        uri: expect.stringContaining('entities/1/attributes/Simple/uri$$'),
+                        type: 'configuration/entityTypes/HCP/attributes/Simple',
+                        value: ''
+                    }
+                ] }) }));
+        expect(result.current.crosswalksMap).toEqual(__assign(__assign({}, initCrosswalksMap), { entity: __assign(__assign({}, initCrosswalksMap.entity), (_a = {}, _a[(_b = result.current.modifiedEntity.attributes) === null || _b === void 0 ? void 0 : _b.Simple[1].uri] = [crosswalk], _a)) }));
+    });
+    it('should return correct add handler for nested attribute', function () {
+        var _a = getModifiedEntity(), onAddAttribute = _a.onAddAttribute, result = _a.result;
+        act(function () {
+            onAddAttribute({
+                attributeType: {
+                    uri: 'configuration/entityTypes/HCP/attributes/Nested',
+                    type: 'Nested',
+                    label: 'Nested',
+                    name: 'Nested',
+                    attributes: [
+                        {
+                            uri: 'configuration/entityTypes/HCP/attributes/Nested/attributes/SubNested',
+                            type: 'String',
+                            name: 'SubNested',
+                            label: 'SubNested'
+                        }
+                    ]
+                },
+                parentUri: 'entities/1'
+            });
+        });
+        expect(result.current.modifiedEntity).toEqual(__assign(__assign({}, entity), { attributes: __assign(__assign({}, entity.attributes), { Nested: [
+                    {
+                        uri: 'entities/1/attributes/Nested/1',
+                        value: {
+                            SubNested: [
+                                {
+                                    uri: 'entities/1/attributes/Nested/1/SubNested/1',
+                                    value: 'subnested value'
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        type: 'configuration/entityTypes/HCP/attributes/Nested',
+                        uri: expect.stringContaining('entities/1/attributes/Nested/uri$$'),
+                        value: {}
+                    }
+                ] }) }));
+        expect(result.current.crosswalksMap).toEqual(initCrosswalksMap);
+    });
+    it('should return correct delete handler for existing attribute', function () {
+        var onDeleteAttribute = getModifiedEntity().onDeleteAttribute;
+        var deleteEvent = {
+            attributeValue: entity.attributes.Simple[0],
+            attributeType: {
+                uri: 'configuration/entityTypes/HCP/attributes/Simple',
+                type: 'Simple',
+                label: 'Simple',
+                name: 'Simple'
+            },
+            crosswalks: [entity.crosswalks[0]]
+        };
+        act(function () {
+            onDeleteAttribute(deleteEvent);
+        });
+        expect(attributeActions.deleteAttribute).toBeCalledWith(deleteEvent);
+    });
+    it('should return correct delete handler for temporary attribute', function () {
+        var _a = getModifiedEntity(), onAddAttribute = _a.onAddAttribute, onDeleteAttribute = _a.onDeleteAttribute, result = _a.result;
+        var crosswalk = {
+            uri: 'entities/1/crosswalks/1',
+            type: 'configuration/sources/Reltio',
+            value: 'cw1',
+            attributes: ['entities/1/attributes/Simple/1'],
+            ownerType: 'entity'
+        };
+        var attributeType = {
+            uri: 'configuration/entityTypes/HCP/attributes/Simple',
+            type: 'Simple',
+            label: 'Simple',
+            name: 'Simple'
+        };
+        act(function () {
+            onAddAttribute({
+                attributeType: attributeType,
+                parentUri: 'entities/1',
+                crosswalk: crosswalk,
+                index: 1
+            });
+        });
+        act(function () {
+            var _a;
+            onDeleteAttribute({
+                attributeValue: (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Simple[1],
+                attributeType: attributeType,
+                crosswalks: [crosswalk]
+            });
+        });
+        expect(attributeActions.deleteAttribute).not.toBeCalled();
+        expect(result.current.modifiedEntity).toEqual(entity);
+        expect(result.current.crosswalksMap).toEqual(initCrosswalksMap);
+    });
+    it('should return correct edit handler for existing attribute', function () {
+        var onEditAttribute = getModifiedEntity().onEditAttribute;
+        var editEvent = {
+            attributeValue: __assign(__assign({}, entity.attributes.Simple[0]), { value: 'new value' }),
+            attributeType: {
+                uri: 'configuration/entityTypes/HCP/attributes/Simple',
+                type: 'Simple',
+                label: 'Simple',
+                name: 'Simple'
+            },
+            crosswalk: entity.crosswalks[0]
+        };
+        act(function () {
+            onEditAttribute(editEvent);
+        });
+        expect(attributeActions.updateAttribute).toBeCalledWith(editEvent);
+    });
+    it('should return correct edit handler for temporary simple attribute', function () {
+        var _a, _b;
+        var _c = getModifiedEntity(), onEditAttribute = _c.onEditAttribute, onAddAttribute = _c.onAddAttribute, result = _c.result;
+        var crosswalk = {
+            uri: 'entities/1/crosswalks/1',
+            type: 'configuration/sources/Reltio',
+            value: 'cw1',
+            attributes: ['entities/1/attributes/Simple/1'],
+            ownerType: 'entity'
+        };
+        var attributeType = {
+            uri: 'configuration/entityTypes/HCP/attributes/Simple',
+            type: 'Simple',
+            label: 'Simple',
+            name: 'Simple'
+        };
+        act(function () {
+            onAddAttribute({
+                attributeType: attributeType,
+                parentUri: 'entities/1',
+                crosswalk: crosswalk,
+                index: 1
+            });
+        });
+        var editEvent = {
+            attributeValue: __assign(__assign({}, (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Simple[1]), { value: 'new value' }),
+            attributeType: attributeType,
+            crosswalk: crosswalk
+        };
+        act(function () {
+            onEditAttribute(editEvent);
+        });
+        expect(attributeActions.updateAttribute).not.toBeCalled();
+        expect(attributeActions.createAttribute).toBeCalledWith({
+            attributeValue: __assign(__assign({}, (_b = result.current.modifiedEntity.attributes) === null || _b === void 0 ? void 0 : _b.Simple[1]), { value: 'new value' }),
+            crosswalk: crosswalk
+        });
+    });
+    it('should return correct edit handler for temporary subnested attribute', function () {
+        var _a, _b;
+        var _c = getModifiedEntity(), onEditAttribute = _c.onEditAttribute, onAddAttribute = _c.onAddAttribute, result = _c.result;
+        var crosswalk = {
+            uri: 'entities/1/crosswalks/1',
+            type: 'configuration/sources/Reltio',
+            value: 'cw1',
+            attributes: ['entities/1/attributes/Simple/1'],
+            ownerType: 'entity'
+        };
+        var attributeType = {
+            uri: 'configuration/entityTypes/HCP/attributes/Nested',
+            type: 'Nested',
+            label: 'Nested',
+            name: 'Nested',
+            attributes: [
+                {
+                    uri: 'configuration/entityTypes/HCP/attributes/Nested/attributes/SubNested',
+                    type: 'String',
+                    name: 'SubNested',
+                    label: 'SubNested'
+                }
+            ]
+        };
+        act(function () {
+            onAddAttribute({
+                attributeType: attributeType,
+                parentUri: 'entities/1',
+                index: 1
+            });
+        });
+        act(function () {
+            var _a;
+            onAddAttribute({
+                attributeType: attributeType.attributes[0],
+                parentUri: (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Nested[1].uri,
+                crosswalk: crosswalk,
+                index: 0
+            });
+        });
+        act(function () {
+            var _a;
+            onEditAttribute({
+                attributeType: attributeType.attributes[0],
+                crosswalk: crosswalk,
+                attributeValue: __assign(__assign({}, (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Nested[1].value.SubNested[0]), { value: 'new value' })
+            });
+        });
+        expect(attributeActions.updateAttribute).not.toBeCalled();
+        expect(attributeActions.createAttribute).toBeCalledWith({
+            attributeValue: __assign(__assign({}, (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Nested[1]), { value: {
+                    SubNested: [
+                        __assign(__assign({}, (_b = result.current.modifiedEntity.attributes) === null || _b === void 0 ? void 0 : _b.Nested[1].value.SubNested[0]), { value: 'new value' })
+                    ]
+                } }),
+            crosswalk: crosswalk
+        });
+    });
+    it('should reset data on entity change', function () {
+        var _a = getModifiedEntity(), onAddAttribute = _a.onAddAttribute, result = _a.result, rerender = _a.rerender;
+        var crosswalk = {
+            uri: 'entities/1/crosswalks/1',
+            type: 'configuration/sources/Reltio',
+            value: 'cw1',
+            attributes: ['entities/1/attributes/Simple/1'],
+            ownerType: 'entity'
+        };
+        act(function () {
+            onAddAttribute({
+                attributeType: {
+                    uri: 'configuration/entityTypes/HCP/attributes/Simple',
+                    type: 'Simple',
+                    label: 'Simple',
+                    name: 'Simple'
+                },
+                parentUri: 'entities/1',
+                crosswalk: crosswalk,
+                index: 1
+            });
+        });
+        expect(result.current.modifiedEntity).not.toEqual(entity);
+        expect(result.current.crosswalksMap).not.toEqual(initCrosswalksMap);
+        rerender(__assign(__assign({}, initialProps), { entity: __assign({}, entity) }));
+        expect(result.current.modifiedEntity).toEqual(entity);
+        expect(result.current.crosswalksMap).toEqual(initCrosswalksMap);
+    });
+    it('should return newlyCreatedAttributes correctly', function () {
+        var _a = getModifiedEntity(), onEditAttribute = _a.onEditAttribute, onAddAttribute = _a.onAddAttribute, result = _a.result, rerender = _a.rerender;
+        var crosswalk = {
+            uri: 'entities/1/crosswalks/1',
+            type: 'configuration/sources/Reltio',
+            value: 'cw1',
+            attributes: ['entities/1/attributes/Simple/1'],
+            ownerType: 'entity'
+        };
+        var attributeType = {
+            uri: 'configuration/entityTypes/HCP/attributes/Nested',
+            type: 'Nested',
+            label: 'Nested',
+            name: 'Nested',
+            attributes: [
+                {
+                    uri: 'configuration/entityTypes/HCP/attributes/Nested/attributes/SubNested',
+                    type: 'String',
+                    name: 'SubNested',
+                    label: 'SubNested'
+                }
+            ]
+        };
+        act(function () {
+            onAddAttribute({
+                attributeType: attributeType,
+                parentUri: 'entities/1',
+                index: 1
+            });
+        });
+        act(function () {
+            var _a;
+            onAddAttribute({
+                attributeType: attributeType.attributes[0],
+                parentUri: (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Nested[1].uri,
+                crosswalk: crosswalk,
+                index: 0
+            });
+        });
+        act(function () {
+            var _a;
+            onEditAttribute({
+                attributeType: attributeType.attributes[0],
+                crosswalk: crosswalk,
+                attributeValue: __assign(__assign({}, (_a = result.current.modifiedEntity.attributes) === null || _a === void 0 ? void 0 : _a.Nested[1].value.SubNested[0]), { value: 'new value' })
+            });
+        });
+        expect(result.current.newlyCreatedAttributes).toEqual([]);
+        rerender(__assign(__assign({}, initialProps), { entity: __assign(__assign({}, entity), { attributes: __assign(__assign({}, entity.attributes), { Nested: [
+                        {
+                            uri: 'entities/1/attributes/Nested/2',
+                            value: {
+                                SubNested: [
+                                    {
+                                        uri: 'entities/1/attributes/Nested/2/SubNested/1',
+                                        value: 'new value'
+                                    }
+                                ]
+                            }
+                        },
+                        {
+                            uri: 'entities/1/attributes/Nested/1',
+                            value: {
+                                SubNested: [
+                                    {
+                                        uri: 'entities/1/attributes/Nested/1/SubNested/1',
+                                        value: 'subnested value'
+                                    }
+                                ]
+                            }
+                        }
+                    ] }), crosswalks: [
+                    {
+                        uri: 'entities/1/crosswalks/1',
+                        type: 'configuration/sources/Reltio',
+                        value: 'cw1',
+                        attributes: [
+                            'entities/1/attributes/Simple/1',
+                            'entities/1/attributes/Nested/2',
+                            'entities/1/attributes/Nested/2/SubNested/1'
+                        ]
+                    },
+                    entity.crosswalks[1]
+                ] }) }));
+        expect(result.current.newlyCreatedAttributes).toEqual([
+            'entities/1/attributes/Nested/2',
+            'entities/1/attributes/Nested/2/SubNested/1'
+        ]);
+    });
+});

package/esm/features/crosswalks/index.d.ts

@@ -0,0 +1,9 @@
+export { AttributesTable } from './AttributesTable';
+export { CrosswalkDragLayer } from './CrosswalkDragLayer';
+export { SourceCrosswalksRow } from './SourceCrosswalksRow';
+export { CrosswalkEditor } from './CrosswalkEditor';
+export { useModifiedEntity } from './hooks/useModifiedEntity';
+export { useCrosswalkActions } from './hooks/useCrosswalkActions';
+export { groupCrosswalksByTypesAndSources } from './utils/legend';
+export { CrosswalkType } from './types';
+export type { CrosswalksByTypes, AddCrosswalkEvent, EditCrosswalkEvent, DeleteCrosswalkEvent } from './types';

package/esm/features/crosswalks/index.js

@@ -0,0 +1,8 @@
+export { AttributesTable } from './AttributesTable';
+export { CrosswalkDragLayer } from './CrosswalkDragLayer';
+export { SourceCrosswalksRow } from './SourceCrosswalksRow';
+export { CrosswalkEditor } from './CrosswalkEditor';
+export { useModifiedEntity } from './hooks/useModifiedEntity';
+export { useCrosswalkActions } from './hooks/useCrosswalkActions';
+export { groupCrosswalksByTypesAndSources } from './utils/legend';
+export { CrosswalkType } from './types';

package/esm/features/crosswalks/types/crosswalks.d.ts

@@ -0,0 +1,12 @@
+import { Crosswalk, RelationCrosswalk } from '@reltio/mdm-sdk';
+import { RelationCrosswalksMap, EntityCrosswalksMap } from '../../../types';
+export declare enum CrosswalkType {
+    Simple = "simple",
+    Empty = "empty",
+    Dependent = "dependent"
+}
+export type CrosswalksByTypes = Record<CrosswalkType, (Crosswalk | RelationCrosswalk)[]>;
+export type CrosswalksByOwnerTypeMap = {
+    entity: EntityCrosswalksMap;
+    relation: RelationCrosswalksMap;
+};

package/esm/features/crosswalks/types/events.d.ts

@@ -0,0 +1,20 @@
+import { Crosswalk, Entity, Relation, AttributeValue, RelationCrosswalk } from '@reltio/mdm-sdk';
+export type AddCrosswalkEvent = {
+    entity: Entity | Relation;
+    contributorCrosswalk?: Crosswalk;
+    crosswalk: Omit<Crosswalk, 'uri'>;
+};
+export type CreateAttributeEvent = {
+    attributeValue: AttributeValue;
+    crosswalk: Crosswalk | RelationCrosswalk;
+};
+export type EditCrosswalkEvent = {
+    entityUri: string;
+    crosswalkId: string;
+    attributeName: string;
+    value?: string;
+};
+export type DeleteCrosswalkEvent = {
+    entityUri: string;
+    crosswalkId: string;
+};

package/esm/features/crosswalks/types/events.js

@@ -0,0 +1 @@
+export {};

package/esm/features/crosswalks/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { AddCrosswalkEvent, CreateAttributeEvent, DeleteCrosswalkEvent, EditCrosswalkEvent } from './events';
+export type { CrosswalksByOwnerTypeMap, CrosswalksByTypes } from './crosswalks';
+export { CrosswalkType } from './crosswalks';

package/esm/features/crosswalks/types/index.js

@@ -0,0 +1 @@
+export { CrosswalkType } from './crosswalks';

package/esm/hooks/useDateEditor/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_MIN_DATE: Date;
+export declare const DEFAULT_MAX_DATE: Date;
+export declare const DEFAULT_MAX_DATE_IN_POPUP: Date;

package/esm/hooks/useDateEditor/constants.js

@@ -0,0 +1,3 @@
+export var DEFAULT_MIN_DATE = new Date('1900-01-01');
+export var DEFAULT_MAX_DATE = new Date('9999-12-31');
+export var DEFAULT_MAX_DATE_IN_POPUP = new Date('2099-12-31');

package/esm/hooks/useDateEditor/helpers.js

@@ -0,0 +1,24 @@
+import i18n from 'ui-i18n';
+import moment from 'moment';
+import { DEFAULT_MAX_DATE_IN_POPUP, DEFAULT_MIN_DATE } from './constants';
+export var getErrorMessage = function (error) {
+    switch (error) {
+        case 'maxDate':
+            return i18n.text('Date should not be after maximal date');
+        case 'minDate':
+            return i18n.text('Date should not be before minimal date');
+        case 'invalidDate':
+            return i18n.text('Invalid Date Format');
+        default:
+            return '';
+    }
+};
+export var isDateRangeError = function (error) { return ['minDate', 'maxDate'].includes(error); };
+export var getEditorMaxDate = function (maxDate) {
+    var date = moment(maxDate).isAfter(DEFAULT_MAX_DATE_IN_POPUP) ? DEFAULT_MAX_DATE_IN_POPUP : maxDate;
+    return moment(date);
+};
+export var getEditorMinDate = function (minDate) {
+    var date = moment(minDate).isBefore(DEFAULT_MIN_DATE) ? DEFAULT_MIN_DATE : minDate;
+    return moment(date);
+};

package/esm/hooks/useDateEditor/index.d.ts

@@ -0,0 +1 @@
+export { useDateEditor } from './useDateEditor';

package/esm/hooks/useDateEditor/index.js

@@ -0,0 +1 @@
+export { useDateEditor } from './useDateEditor';

package/esm/hooks/useDateEditor/useDateEditor.js

@@ -0,0 +1,55 @@
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import moment from 'moment';
+import { isNil } from 'ramda';
+import { utils, debounce } from '@reltio/mdm-sdk';
+import { getEditorMaxDate, getEditorMinDate, getErrorMessage, isDateRangeError } from './helpers';
+import { DEFAULT_MAX_DATE, DEFAULT_MIN_DATE } from './constants';
+var _a = utils.dates, isValidMomentDateOrNull = _a.isValidMomentDateOrNull, isDateInRange = _a.isDateInRange, momentToDate = _a.momentToDate;
+export var useDateEditor = function (_a) {
+    var minDateProp = _a.minDate, maxDateProp = _a.maxDate, value = _a.value, onChange = _a.onChange;
+    var _b = useState(null), error = _b[0], setError = _b[1];
+    var _c = useState(null), editorValue = _c[0], setEditorValue = _c[1];
+    var minDate = useMemo(function () { return utils.dates.clearDateTime(isNil(minDateProp) ? DEFAULT_MIN_DATE : minDateProp); }, [minDateProp]);
+    var maxDate = useMemo(function () { return utils.dates.clearDateTime(isNil(maxDateProp) ? DEFAULT_MAX_DATE : maxDateProp); }, [maxDateProp]);
+    var momentValue = useMemo(function () { return (isNil(value) ? null : moment(value)); }, [value]);
+    var editorMinDate = useMemo(function () { return getEditorMinDate(minDate); }, [minDate]);
+    var editorMaxDate = useMemo(function () { return getEditorMaxDate(maxDate); }, [maxDate]);
+    var errorMessage = useMemo(function () { return getErrorMessage(error); }, [error]);
+    var handleError = useCallback(function (error) {
+        if (!isDateRangeError(error))
+            setError(error);
+    }, []);
+    var handleChange = useCallback(function (value) {
+        setEditorValue(value);
+        if (isValidMomentDateOrNull(value) && isDateInRange(minDate, maxDate)(value)) {
+            onChange(momentToDate(value));
+        }
+    }, [minDate, maxDate, onChange]);
+    var debouncedHandleChange = useCallback(debounce(handleChange, 0), [handleChange]);
+    useEffect(function () {
+        setEditorValue(function (prevEditorValue) {
+            var datesAreTheSame = moment(prevEditorValue).isSame(momentValue);
+            var datesAreInvalid = !isValidMomentDateOrNull(momentValue) && !isValidMomentDateOrNull(prevEditorValue);
+            return datesAreTheSame || datesAreInvalid ? prevEditorValue : momentValue;
+        });
+    }, [momentValue]);
+    useEffect(function () {
+        if (editorValue === null || editorValue === void 0 ? void 0 : editorValue.isAfter(maxDate)) {
+            setError('maxDate');
+        }
+        else if (editorValue === null || editorValue === void 0 ? void 0 : editorValue.isBefore(minDate)) {
+            setError('minDate');
+        }
+        else {
+            setError(function (prevError) { return (isDateRangeError(prevError) ? null : prevError); });
+        }
+    }, [editorValue, maxDate, minDate]);
+    return {
+        errorMessage: errorMessage,
+        editorValue: editorValue,
+        editorMinDate: editorMinDate,
+        editorMaxDate: editorMaxDate,
+        onChange: debouncedHandleChange,
+        onError: handleError
+    };
+};