@reltio/components 1.4.1818 → 1.4.1820

package/esm/DataTypeValue/DataTypeValue.test.js

@@ -0,0 +1,141 @@
+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 React from 'react';
+import { screen, render } from '@testing-library/react';
+import moment from 'moment';
+import * as mdmSdk from '@reltio/mdm-sdk';
+import { MdmModuleProvider } from '../contexts/MdmModuleContext';
+import { DataTypeValue } from './DataTypeValue';
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { formatDataTypeValue: jest.fn().mockImplementation(jest.requireActual('@reltio/mdm-sdk').formatDataTypeValue) })); });
+var defaultAttributesPresentation = { attr1: {} };
+var defaultDateMask = '99-99-99';
+var defaultDateTimeMask = '99-99-99 99:99:99';
+var defaultMdmValues = {
+    attributesPresentation: defaultAttributesPresentation,
+    dateMask: defaultDateMask,
+    dateTimeMask: defaultDateTimeMask
+};
+var setUp = function (props, mdmValues) {
+    if (mdmValues === void 0) { mdmValues = defaultMdmValues; }
+    var Providers = function (_a) {
+        var children = _a.children;
+        return React.createElement(MdmModuleProvider, { values: mdmValues }, children);
+    };
+    return render(React.createElement(DataTypeValue, __assign({}, props)), { wrapper: Providers });
+};
+describe('DataTypeValue tests', function () {
+    var checkFormatDataTypeCall = function (_a) {
+        var _b = _a.attributesPresentation, attributesPresentation = _b === void 0 ? defaultAttributesPresentation : _b, _c = _a.dateMask, dateMask = _c === void 0 ? defaultDateMask : _c, _d = _a.dateTimeMask, dateTimeMask = _d === void 0 ? defaultDateTimeMask : _d, dataTypeDefinition = _a.dataTypeDefinition, value = _a.value;
+        expect(mdmSdk.formatDataTypeValue).toHaveBeenCalledWith({ attributesPresentation: attributesPresentation, dateMask: dateMask, dateTimeMask: dateTimeMask, dataTypeDefinition: dataTypeDefinition }, value);
+    };
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should render regular attribute', function () {
+        var value = '123';
+        var dataTypeDefinition = { type: 'String' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText(value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should render attribute with timestamp and system format if masks were not configured', function () {
+        var value = '03/05/2020';
+        var dataTypeDefinition = { type: 'Date' };
+        var mdmValues = __assign(__assign({}, defaultMdmValues), { dateMask: undefined, dateTimeMask: undefined });
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition }, mdmValues);
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText(value);
+        checkFormatDataTypeCall({
+            dataTypeDefinition: dataTypeDefinition,
+            value: value,
+            dateMask: moment.localeData().longDateFormat('L'),
+            dateTimeMask: moment.localeData().longDateFormat('L') + ' ' + moment.localeData().longDateFormat('LTS')
+        });
+    });
+    it('should render attribute with date and dateMask', function () {
+        var value = '03/05/2020';
+        var dataTypeDefinition = { type: 'Date' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText('03-05-20');
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should render URL attribute as Link', function () {
+        var value = 'https://reltio.com';
+        var dataTypeDefinition = { type: 'URL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.getByText(value)).toHaveAttribute('href', value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should render Blog URL attribute as Link', function () {
+        var value = 'https://reltio.com';
+        var dataTypeDefinition = { type: 'Blog URL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.getByText(value)).toHaveAttribute('href', value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should render Image URL attribute as Link', function () {
+        var value = 'https://reltio.com';
+        var dataTypeDefinition = { type: 'Image URL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.getByText(value)).toHaveAttribute('href', value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should make absolute for url attribute', function () {
+        var value = 'www.reltio.com';
+        var dataTypeDefinition = { type: 'URL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        var expectedUrl = 'http://' + value; // NOSONAR
+        expect(screen.getByText(value)).toHaveAttribute('href', expectedUrl);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should render Email attribute as Link', function () {
+        var value = 'it@reltio.com';
+        var dataTypeDefinition = { type: 'Email' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.getByText(value)).toHaveAttribute('href', 'mailto:' + value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should not render attribute as Link if its type is not URL/BLOG_URL/IMAGE_URL/Email', function () {
+        var value = 'https://reltio.com';
+        var dataTypeDefinition = { type: 'notURL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText(value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should not render url attribute as Link if "rich" prop is false', function () {
+        var value = 'https://reltio.com';
+        var dataTypeDefinition = { type: 'URL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition, rich: false });
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText(value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should not render url attribute as Link if url is not valid', function () {
+        var value = 'httpsreltiocom';
+        var dataTypeDefinition = { type: 'URL' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText(value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+    it('should not render email attribute as Link if email is not valid', function () {
+        var value = 'itreltio.com';
+        var dataTypeDefinition = { type: 'Email' };
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition });
+        expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        screen.getByText(value);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
+    });
+});

package/esm/DataTypeValue/index.d.ts

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

package/esm/DataTypeValue/index.js

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

package/esm/DataTypeValueEditor/DataTypeValueEditor.js

@@ -0,0 +1,48 @@
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { memo } from 'react';
+import PropTypes from 'prop-types';
+import { has, is, mergeDeepLeft } from 'ramda';
+import { isEmptyValue } from '@reltio/mdm-sdk';
+import { COMMON_TEXT_FIELD_PROPS } from '../constants';
+import { EditorsFactory } from '../EditorsFactory';
+import { useEditorContext } from './useEditorContext';
+import { useStyles } from './styles';
+var DataTypeValueEditor = function (_a) {
+    var fieldName = _a.fieldName, value = _a.value, onChange = _a.onChange, dataTypeDefinition = _a.dataTypeDefinition, _b = _a.TextFieldProps, TextFieldProps = _b === void 0 ? {} : _b, otherProps = __rest(_a, ["fieldName", "value", "onChange", "dataTypeDefinition", "TextFieldProps"]);
+    var styles = useStyles();
+    var editorContext = useEditorContext(fieldName, dataTypeDefinition);
+    var isEmpty = function (value) {
+        return is(Object, value) && has('value', value) ? isEmptyValue(value.value) : isEmptyValue(value);
+    };
+    TextFieldProps = mergeDeepLeft(TextFieldProps, __assign(__assign({}, COMMON_TEXT_FIELD_PROPS), { className: styles.marginDense, InputProps: __assign(__assign({}, COMMON_TEXT_FIELD_PROPS.InputProps), { disableUnderline: isEmpty(value) }) }));
+    return EditorsFactory.build(dataTypeDefinition.type, __assign(__assign({ onChange: onChange, value: value, TextFieldProps: TextFieldProps }, editorContext), otherProps));
+};
+DataTypeValueEditor.propTypes = {
+    fieldName: PropTypes.string,
+    value: PropTypes.any,
+    onChange: PropTypes.func,
+    dataTypeDefinition: PropTypes.object
+};
+DataTypeValueEditor.displayName = 'DataTypeValueEditor';
+export default memo(DataTypeValueEditor);

package/esm/DataTypeValueEditor/index.d.ts

@@ -0,0 +1 @@
+export { default as DataTypeValueEditor } from './DataTypeValueEditor';

package/esm/DataTypeValueEditor/index.js

@@ -0,0 +1 @@
+export { default as DataTypeValueEditor } from './DataTypeValueEditor';

package/esm/DataTypeValueEditor/styles.d.ts

@@ -0,0 +1 @@
+export declare const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"marginDense">;

package/esm/DataTypeValueEditor/styles.js

@@ -0,0 +1,6 @@
+import { makeStyles } from '@mui/styles';
+export var useStyles = makeStyles({
+    marginDense: {
+        margin: 0
+    }
+});

package/esm/DataTypeValueEditor/useEditorContext.d.ts

@@ -0,0 +1,71 @@
+import { DataTypeDefinition } from '@reltio/mdm-sdk';
+export declare const useEditorContext: (fieldName: string, dataTypeDefinition: DataTypeDefinition) => {
+    lookups: import("@reltio/mdm-sdk").Lookups;
+    lookupCode: string;
+    getLookups: () => any;
+    resolveLookups?: undefined;
+    getSuggestions?: undefined;
+    format?: undefined;
+    tenant?: undefined;
+    entries?: undefined;
+} | {
+    lookups: import("@reltio/mdm-sdk").Lookups;
+    lookupCode: string;
+    getLookups: ({ type, parents, displayNamePrefix, max, offset }: {
+        type: any;
+        parents: any;
+        displayNamePrefix: any;
+        max: any;
+        offset: any;
+    }) => Promise<any>;
+    resolveLookups: (type: any, codeValues: any) => Promise<void>;
+    getSuggestions?: undefined;
+    format?: undefined;
+    tenant?: undefined;
+    entries?: undefined;
+} | {
+    getSuggestions: (searchValue: any, max: any, pageNo: any) => Promise<Record<string, unknown>>;
+    lookups?: undefined;
+    lookupCode?: undefined;
+    getLookups?: undefined;
+    resolveLookups?: undefined;
+    format?: undefined;
+    tenant?: undefined;
+    entries?: undefined;
+} | {
+    format: import("@reltio/mdm-sdk").NumberFormat;
+    lookups?: undefined;
+    lookupCode?: undefined;
+    getLookups?: undefined;
+    resolveLookups?: undefined;
+    getSuggestions?: undefined;
+    tenant?: undefined;
+    entries?: undefined;
+} | {
+    tenant: string;
+    lookups?: undefined;
+    lookupCode?: undefined;
+    getLookups?: undefined;
+    resolveLookups?: undefined;
+    getSuggestions?: undefined;
+    format?: undefined;
+    entries?: undefined;
+} | {
+    entries: unknown[];
+    lookups?: undefined;
+    lookupCode?: undefined;
+    getLookups?: undefined;
+    resolveLookups?: undefined;
+    getSuggestions?: undefined;
+    format?: undefined;
+    tenant?: undefined;
+} | {
+    lookups?: undefined;
+    lookupCode?: undefined;
+    getLookups?: undefined;
+    resolveLookups?: undefined;
+    getSuggestions?: undefined;
+    format?: undefined;
+    tenant?: undefined;
+    entries?: undefined;
+};

package/esm/DataTypeValueEditor/useEditorContext.js

@@ -0,0 +1,84 @@
+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 { useCallback } from 'react';
+import { propOr, prop, pipe, keys } from 'ramda';
+import { DataTypes, intl, getDependentLookups, getFacetedAttributeData, getLookups, resolveLookupsList, getNumberFormat } from '@reltio/mdm-sdk';
+import { useMdmAction, useMdmAttributesPresentation, useMdmGlobalSearchRequestOptions, useMdmLookups, useMdmTenant } from '../contexts/MdmModuleContext';
+export var useEditorContext = function (fieldName, dataTypeDefinition) {
+    var lookupsLoaded = useMdmAction('lookupsLoaded');
+    var lookupsForTypeResolved = useMdmAction('lookupsForTypeResolved');
+    var tenant = useMdmTenant();
+    var lookups = useMdmLookups();
+    var attributesPresentation = useMdmAttributesPresentation();
+    var globalSearchRequestOptions = useMdmGlobalSearchRequestOptions();
+    var typeaheadGetSuggestion = useCallback(function (searchValue, max, pageNo) {
+        return getFacetedAttributeData({
+            fieldName: fieldName,
+            searchValue: searchValue,
+            options: __assign(__assign({}, globalSearchRequestOptions), { max: max, pageNo: pageNo })
+        }).then(pipe(prop(fieldName), keys));
+    }, [fieldName, globalSearchRequestOptions]);
+    var type = dataTypeDefinition.type, values = dataTypeDefinition.values, lookupCode = dataTypeDefinition.lookupCode, dependentLookupCode = dataTypeDefinition.dependentLookupCode, options = dataTypeDefinition.options;
+    switch (type) {
+        case DataTypes.TYPE_ENUM:
+            return { entries: values.map(function (value) { return ({ value: value }); }) };
+        case DataTypes.TYPE_LOOKUP:
+            return {
+                lookups: lookups,
+                lookupCode: lookupCode,
+                getLookups: function () {
+                    return getLookups().then(function (lookups) {
+                        lookupsLoaded(lookups);
+                    });
+                }
+            };
+        case DataTypes.TYPE_DEPENDENT_LOOKUP:
+            return {
+                lookups: lookups,
+                lookupCode: dependentLookupCode,
+                getLookups: function (_a) {
+                    var type = _a.type, parents = _a.parents, displayNamePrefix = _a.displayNamePrefix, max = _a.max, offset = _a.offset;
+                    return getDependentLookups({ type: type, parents: parents, displayNamePrefix: displayNamePrefix, max: max, offset: offset }).then(function (_a) {
+                        var codeValues = _a.codeValues;
+                        return propOr({}, type, codeValues);
+                    });
+                },
+                resolveLookups: function (type, codeValues) {
+                    var lookupsList = codeValues.map(function (codeValue) { return ({ type: type, codeValue: codeValue }); });
+                    return resolveLookupsList(lookupsList).then(function (response) {
+                        if (Array.isArray(response)) {
+                            var lookups_1 = response.reduce(function (acc, lookupData) { return (__assign(__assign({}, acc), lookupData[type])); }, {});
+                            lookupsForTypeResolved({ type: type, values: lookups_1 });
+                        }
+                    });
+                }
+            };
+        case DataTypes.TYPE_TYPEAHEAD:
+            return {
+                getSuggestions: typeaheadGetSuggestion
+            };
+        case DataTypes.TYPE_NUMBER:
+        case DataTypes.TYPE_FLOAT:
+        case DataTypes.TYPE_DOUBLE:
+        case DataTypes.TYPE_LONG:
+        case DataTypes.TYPE_INT:
+            return {
+                format: getNumberFormat(dataTypeDefinition, attributesPresentation, intl.getLocale())
+            };
+        case DataTypes.TYPE_FILE:
+            return { tenant: tenant };
+        case DataTypes.TYPE_SELECT:
+            return { entries: options };
+        default:
+            return {};
+    }
+};

package/esm/DataTypeValueEditor/useEditorContext.test.d.ts

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

package/esm/DataTypeValueEditor/useEditorContext.test.js

@@ -0,0 +1,201 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import React from 'react';
+import { renderHook } from '@testing-library/react-hooks';
+import { getFacetedAttributeData, DataTypes, getLookups, getDependentLookups, resolveLookupsList } from '@reltio/mdm-sdk';
+import { MdmModuleProvider } from '../contexts/MdmModuleContext';
+import { useEditorContext } from './useEditorContext';
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getFacetedAttributeData: jest.fn(), getLookups: jest.fn(), getDependentLookups: jest.fn(), resolveLookupsList: jest.fn() })); });
+var lookupsLoaded = jest.fn();
+var lookupsForTypeResolved = jest.fn();
+var setUp = function (props) {
+    var Providers = function (_a) {
+        var children = _a.children;
+        return React.createElement(MdmModuleProvider, { actions: { lookupsLoaded: lookupsLoaded, lookupsForTypeResolved: lookupsForTypeResolved } }, children);
+    };
+    return renderHook(function (_a) {
+        var fieldName = _a.fieldName, dataTypeDefinition = _a.dataTypeDefinition;
+        return useEditorContext(fieldName, dataTypeDefinition);
+    }, {
+        initialProps: props,
+        wrapper: Providers
+    });
+};
+describe('useEditorContext tests', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should return getSuggestions which return suggestions correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fieldName, dataTypeDefinition, response, result, searchValue, max, pageNo, suggestions;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fieldName = 'attributes.fieldName';
+                    dataTypeDefinition = { type: DataTypes.TYPE_TYPEAHEAD };
+                    response = (_a = {}, _a[fieldName] = { 'suggested value': 10 }, _a);
+                    getFacetedAttributeData.mockResolvedValue(response);
+                    result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+                    searchValue = 'value';
+                    max = 100;
+                    pageNo = 10;
+                    return [4 /*yield*/, result.current.getSuggestions('value', 100, pageNo)];
+                case 1:
+                    suggestions = _b.sent();
+                    expect(getFacetedAttributeData).toHaveBeenCalledWith({
+                        fieldName: fieldName,
+                        searchValue: searchValue,
+                        options: { max: max, pageNo: pageNo, activityFilter: undefined, globalFilter: '', searchOptions: '' }
+                    });
+                    expect(suggestions).toEqual(['suggested value']);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return getSuggestions which return suggestions correctly if response has not fieldName', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fieldName, dataTypeDefinition, result, suggestions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getFacetedAttributeData.mockResolvedValue({});
+                    fieldName = 'attributes.TextField';
+                    dataTypeDefinition = { type: DataTypes.TYPE_TYPEAHEAD };
+                    result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+                    return [4 /*yield*/, result.current.getSuggestions('value', 100, 0)];
+                case 1:
+                    suggestions = _a.sent();
+                    expect(suggestions).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return getLookups which dispatches an action for "Lookup" type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var response, fieldName, dataTypeDefinition, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    response = { AA: { lookups: [] } };
+                    getLookups.mockResolvedValue(response);
+                    fieldName = '';
+                    dataTypeDefinition = { type: DataTypes.TYPE_LOOKUP };
+                    result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+                    return [4 /*yield*/, result.current.getLookups({ type: 'AA', parents: [], displayNamePrefix: '', max: 20, offset: 0 })];
+                case 1:
+                    _a.sent();
+                    expect(lookupsLoaded).toHaveBeenCalledWith(response);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return entries for "Select" type', function () {
+        var options = [
+            { value: 1, label: '1' },
+            { value: 2, label: '2' }
+        ];
+        var fieldName = '';
+        var dataTypeDefinition = { type: DataTypes.TYPE_SELECT, options: options };
+        var result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+        expect(result.current.entries).toEqual(options);
+    });
+    it('should return getLookups which returns lookups for "Dependent Lookup" type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var response, fieldName, dataTypeDefinition, result, params, lookups;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    response = {
+                        codeValues: {
+                            COUNTRY_CD: {
+                                DE: { displayName: 'Germany' },
+                                RU: { displayName: 'Russia' }
+                            }
+                        }
+                    };
+                    getDependentLookups.mockResolvedValue(response);
+                    fieldName = 'attributes.CountryCode';
+                    dataTypeDefinition = { type: DataTypes.TYPE_DEPENDENT_LOOKUP, dependentLookupCode: 'COUNTRY_CD' };
+                    result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+                    params = { type: 'COUNTRY_CD', parents: [], displayNamePrefix: '', max: 20, offset: 0 };
+                    return [4 /*yield*/, result.current.getLookups(params)];
+                case 1:
+                    lookups = _a.sent();
+                    expect(getDependentLookups).toBeCalledWith(params);
+                    expect(lookups).toEqual({ DE: { displayName: 'Germany' }, RU: { displayName: 'Russia' } });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return resolveLookups which dispatches an action for "Dependent Lookup" type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var response, fieldName, dataTypeDefinition, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    response = [{ COUNTRY_CD: { DE: { displayName: 'Germany' } } }];
+                    resolveLookupsList.mockResolvedValue(response);
+                    fieldName = 'attributes.CountryCode';
+                    dataTypeDefinition = { type: DataTypes.TYPE_DEPENDENT_LOOKUP, dependentLookupCode: 'COUNTRY_CD' };
+                    result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+                    return [4 /*yield*/, result.current.resolveLookups('COUNTRY_CD', ['DE'])];
+                case 1:
+                    _a.sent();
+                    expect(resolveLookupsList).toBeCalledWith([{ type: 'COUNTRY_CD', codeValue: 'DE' }]);
+                    expect(lookupsForTypeResolved).toHaveBeenCalledWith({
+                        type: 'COUNTRY_CD',
+                        values: { DE: { displayName: 'Germany' } }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return entries for "Enum" type', function () {
+        var values = ['Enum1', 'Enum2', 'Enum3'];
+        var fieldName = '';
+        var dataTypeDefinition = { type: DataTypes.TYPE_ENUM, values: values };
+        var result = setUp({ fieldName: fieldName, dataTypeDefinition: dataTypeDefinition }).result;
+        expect(result.current.entries).toEqual([{ value: 'Enum1' }, { value: 'Enum2' }, { value: 'Enum3' }]);
+    });
+});

package/esm/DateEditor/DateEditor.d.ts

@@ -0,0 +1,11 @@
+import { Moment } from 'moment';
+import { DatePickerProps } from '@mui/x-date-pickers/DatePicker';
+type Props = Omit<DatePickerProps<Moment>, 'value' | 'minDate' | 'maxDate' | 'onChange'> & {
+    minDate?: Date | number;
+    maxDate?: Date | number;
+    value?: Date | number;
+    onChange: (value: Date) => void;
+    isCrossedOut?: boolean;
+};
+export declare const DateEditor: ({ minDate, maxDate, value: valueProp, format, label, onChange, slotProps, isCrossedOut, ...otherProps }: Props) => JSX.Element;
+export {};

package/esm/DateEditor/DateEditor.js

@@ -0,0 +1,56 @@
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { useMemo } from 'react';
+import moment from 'moment';
+import classnames from 'classnames';
+import { mergeDeepLeft, isNil } from 'ramda';
+import { utils } from '@reltio/mdm-sdk';
+import { DatePicker } from '@mui/x-date-pickers/DatePicker';
+import { useDateEditor } from '../hooks/useDateEditor';
+import { useStyles } from './styles';
+export var DateEditor = function (_a) {
+    var _b;
+    var minDate = _a.minDate, maxDate = _a.maxDate, valueProp = _a.value, format = _a.format, label = _a.label, onChange = _a.onChange, slotProps = _a.slotProps, isCrossedOut = _a.isCrossedOut, otherProps = __rest(_a, ["minDate", "maxDate", "value", "format", "label", "onChange", "slotProps", "isCrossedOut"]);
+    var styles = useStyles();
+    var value = useMemo(function () { return (isNil(valueProp) ? null : utils.dates.clearDateTime(valueProp)); }, [valueProp]);
+    var _c = useDateEditor({ minDate: minDate, maxDate: maxDate, value: value, onChange: onChange }), errorMessage = _c.errorMessage, editorValue = _c.editorValue, editorMaxDate = _c.editorMaxDate, editorMinDate = _c.editorMinDate, onError = _c.onError, handleChange = _c.onChange;
+    var basicSlotProps = {
+        textField: {
+            size: 'small',
+            variant: 'filled',
+            helperText: errorMessage,
+            error: Boolean(errorMessage),
+            InputProps: {
+                classes: {
+                    root: classnames(styles.inputRoot, (_b = {}, _b[styles.isCrossedOut] = isCrossedOut, _b))
+                },
+                disableUnderline: isNil(editorValue)
+            },
+            InputLabelProps: { shrink: !isNil(label) }
+        },
+        popper: { placement: 'bottom-start' },
+        inputAdornment: { position: 'end', className: styles.adornedEnd }
+    };
+    var editorSlotProps = mergeDeepLeft(slotProps, basicSlotProps);
+    return (React.createElement(DatePicker, __assign({ format: format || moment.localeData().longDateFormat('L'), slotProps: editorSlotProps, views: ['year', 'month', 'day'], label: label, value: editorValue, minDate: editorMinDate, maxDate: editorMaxDate, onError: onError, onChange: handleChange }, otherProps)));
+};

package/esm/DateEditor/DateEditor.test.d.ts

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