@reltio/components 1.4.1824-hf-2 → 1.4.1824

package/esm/ConnectionRelationTypeSelector/ConnectionRelationTypeSelector.test.js

@@ -0,0 +1,176 @@
+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 { shallow } from 'enzyme';
+import { path, pick, propEq } from 'ramda';
+import { Directions } from '@reltio/mdm-sdk';
+import { RelationTypeSelector } from '../RelationTypeSelector';
+import { ConnectionRelationTypeSelector } from './ConnectionRelationTypeSelector';
+var relationTypes = [
+    {
+        uri: 'configuration/relationTypes/AccountTeam',
+        label: 'supported by',
+        startObject: {
+            uri: 'configuration/relationTypes/AccountTeam/startObject',
+            directionalContext: [
+                {
+                    uri: 'configuration/relationTypes/AccountTeam/startObject/directionalContext',
+                    labelPattern: 'supported by'
+                }
+            ],
+            objectTypeURI: 'configuration/entityTypes/Organization'
+        },
+        endObject: {
+            uri: 'configuration/relationTypes/AccountTeam/endObject',
+            directionalContext: [
+                {
+                    uri: 'configuration/relationTypes/AccountTeam/endObject/directionalContext',
+                    labelPattern: 'supports'
+                }
+            ],
+            objectTypeURI: 'configuration/entityTypes/Employee'
+        },
+        attributes: [
+            {
+                label: 'Role',
+                name: 'Role',
+                type: 'String',
+                hidden: false,
+                important: false,
+                system: false,
+                required: false,
+                attributeOrdering: {
+                    orderType: 'ASC',
+                    orderingStrategy: 'LUD'
+                },
+                uri: 'configuration/relationTypes/AccountTeam/attributes/Role'
+            }
+        ],
+        direction: 'directed'
+    },
+    {
+        uri: 'configuration/relationTypes/knowledge',
+        label: 'knowledge',
+        startObject: {
+            uri: 'configuration/relationTypes/knowledge/startObject',
+            directionalContext: [
+                {
+                    uri: 'configuration/relationTypes/knowledge/startObject/directionalContext',
+                    labelPattern: ''
+                }
+            ],
+            objectTypeURI: 'configuration/entityTypes/Topic'
+        },
+        endObject: {
+            uri: 'configuration/relationTypes/knowledge/endObject',
+            directionalContext: [
+                {
+                    uri: 'configuration/relationTypes/knowledge/endObject/directionalContext',
+                    labelPattern: ''
+                }
+            ],
+            objectTypeURI: 'configuration/entityTypes/Employee'
+        },
+        attributes: [
+            {
+                label: 'Role',
+                name: 'Role',
+                type: 'String',
+                hidden: false,
+                important: false,
+                system: false,
+                required: false,
+                attributeOrdering: {
+                    orderType: 'ASC',
+                    orderingStrategy: 'LUD'
+                },
+                uri: 'configuration/relationTypes/knowledge/attributes/Role'
+            }
+        ],
+        direction: 'directed'
+    }
+];
+// make useEffect work in shallow render
+jest.mock('react', function () { return (__assign(__assign({}, jest.requireActual('react')), { useEffect: jest.fn().mockImplementation(function (f) { return f(); }) })); });
+describe('ConnectionRelationTypeSelector tests', function () {
+    var expectedOptions = [
+        __assign({ label: relationTypes[1].label, value: "".concat(relationTypes[1].uri, ",").concat(Directions.IN) }, pick(['startObject', 'endObject'], relationTypes[1])),
+        __assign({ label: path(['directionalContext', 0, 'labelPattern'], relationTypes[0].endObject), value: "".concat(relationTypes[0].uri, ",").concat(Directions.OUT) }, pick(['startObject', 'endObject'], relationTypes[0]))
+    ];
+    it('should render main parts', function () {
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, null));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+    });
+    it('should render correct props', function () {
+        var relation = { relationType: 'configuration/relationTypes/AccountTeam', direction: Directions.OUT };
+        var expectedValue = expectedOptions.find(propEq('value', "".concat(relation.relationType, ",").concat(relation.direction)));
+        var onChange = jest.fn();
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, { relation: relation, inRelationTypes: [relationTypes[1]], outRelationTypes: [relationTypes[0]], onChange: onChange }));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+        expect(selector.prop('options')).toStrictEqual(expectedOptions);
+        expect(selector.prop('value')).toStrictEqual(expectedValue);
+        expect(onChange).not.toHaveBeenCalled();
+    });
+    it('should call onChange when RelationTypeSelector onChange was called', function () {
+        var expectedRelationType = {
+            type: relationTypes[0],
+            direction: Directions.OUT
+        };
+        var onChange = jest.fn();
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, { inRelationTypes: [relationTypes[1]], outRelationTypes: [relationTypes[0]], onChange: onChange }));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+        selector.prop('onChange')(expectedOptions[1]);
+        expect(onChange).toHaveBeenCalledWith(expectedRelationType);
+    });
+    it('should not fail when onChange prop is undefined', function () {
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, { inRelationTypes: [relationTypes[1]], outRelationTypes: [relationTypes[0]] }));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+        selector.prop('onChange')(expectedOptions[1]);
+    });
+    it('should set first relation if applyFirstByDefault is true and Selector is empty', function () {
+        var expectedRelation = {
+            direction: Directions.IN,
+            type: relationTypes[1]
+        };
+        var onChange = jest.fn();
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, { inRelationTypes: [relationTypes[1]], outRelationTypes: [relationTypes[0]], applyFirstByDefault: true, onChange: onChange }));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+        expect(selector.prop('options')).toStrictEqual(expectedOptions);
+        expect(onChange).toHaveBeenCalledWith(expectedRelation);
+    });
+    it('should not set first relation if applyFirstByDefault is true and Selector is not empty', function () {
+        var relation = {
+            direction: Directions.OUT,
+            relationUri: 'relations/uri123',
+            relationType: relationTypes[0].uri
+        };
+        var onChange = jest.fn();
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, { relation: relation, inRelationTypes: [relationTypes[1]], outRelationTypes: [relationTypes[0]], applyFirstByDefault: true, onChange: onChange }));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+        expect(selector.prop('options')).toStrictEqual(expectedOptions);
+        expect(onChange).not.toHaveBeenCalled();
+    });
+    it('should not set first relation if applyFirstByDefault is false', function () {
+        var onChange = jest.fn();
+        var component = shallow(React.createElement(ConnectionRelationTypeSelector, { inRelationTypes: [relationTypes[1]], outRelationTypes: [relationTypes[0]], applyFirstByDefault: false, onChange: onChange }));
+        var selector = component.find(RelationTypeSelector);
+        expect(selector).toHaveLength(1);
+        expect(selector.prop('options')).toStrictEqual(expectedOptions);
+        expect(onChange).not.toHaveBeenCalled();
+    });
+});

package/esm/ConnectionRelationTypeSelector/index.d.ts

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

package/esm/ConnectionRelationTypeSelector/index.js

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

package/esm/CustomDateRangeEditor/CustomDateRangeEditor.d.ts

@@ -0,0 +1,8 @@
+type DateValues = [Date, Date];
+type Props = {
+    values: DateValues;
+    onChange: (values: DateValues) => void;
+    onFocus?: () => void;
+};
+export declare const CustomDateRangeEditor: ({ values, onChange, onFocus }: Props) => JSX.Element;
+export {};

package/esm/CustomDateRangeEditor/CustomDateRangeEditor.js

@@ -0,0 +1,55 @@
+import React, { useCallback, useRef, useState } from 'react';
+import moment from 'moment';
+import i18n from 'ui-i18n';
+import { isNil } from 'ramda';
+import { DataTypes, formatDataTypeValue } from '@reltio/mdm-sdk';
+import TextField from '@mui/material/TextField';
+import Popover from '@mui/material/Popover';
+import { noop } from '../core';
+import { ReactSelectDropdownIndicatorWithIconButton } from '../ReactSelectDropdownIndicatorWithIconButton';
+import { DateRangePicker } from '../DateRangePicker';
+import { useStyles } from './styles';
+var localeFormat = moment.localeData().longDateFormat('L');
+var formatValue = function (value, placeholder) {
+    return isNil(value)
+        ? "".concat(placeholder)
+        : "".concat(formatDataTypeValue({ dataTypeDefinition: { type: DataTypes.TYPE_ACTIVENESS_DATE } }, value));
+};
+export var CustomDateRangeEditor = function (_a) {
+    var values = _a.values, onChange = _a.onChange, _b = _a.onFocus, onFocus = _b === void 0 ? noop : _b;
+    var placeholder = localeFormat;
+    var inputRef = useRef(null);
+    var _c = useState(false), open = _c[0], setOpen = _c[1];
+    var styles = useStyles();
+    var onApply = function (values) {
+        onChange(values);
+        setOpen(false);
+    };
+    var handleToggle = useCallback(function () {
+        setOpen(function (open) { return !open; });
+        onFocus();
+    }, [onFocus]);
+    var onCancel = function () {
+        setOpen(false);
+    };
+    return (React.createElement("div", { className: styles.root },
+        React.createElement(TextField, { fullWidth: true, value: values.map(function (value) { return formatValue(value, placeholder); }).join(' \u2014 '), onClick: handleToggle, variant: "filled", ref: inputRef, InputProps: {
+                endAdornment: (React.createElement(ReactSelectDropdownIndicatorWithIconButton, { selectProps: { classes: styles, menuIsOpen: open }, innerProps: {} })),
+                disableUnderline: isNil(values),
+                readOnly: true,
+                classes: {
+                    root: styles.inputRoot,
+                    input: styles.input
+                }
+            }, InputLabelProps: {
+                shrink: false
+            }, placeholder: i18n.text("".concat(placeholder, " \u2014 ").concat(placeholder)) }),
+        React.createElement(Popover, { open: open, anchorEl: inputRef.current, onClose: onCancel, anchorOrigin: {
+                vertical: 'bottom',
+                horizontal: 'right'
+            }, transformOrigin: {
+                vertical: 'top',
+                horizontal: 'right'
+            }, elevation: 2 },
+            React.createElement(DateRangePicker, { values: values, onApply: onApply, type: DataTypes.TYPE_ACTIVENESS_DATE }))));
+};

package/esm/CustomDateRangeEditor/CustomDateRangeEditor.test.d.ts

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

package/esm/CustomDateRangeEditor/CustomDateRangeEditor.test.js

@@ -0,0 +1,153 @@
+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 { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
+import { AdapterMoment } from '@mui/x-date-pickers/AdapterMoment';
+import { CustomDateRangeEditor } from './CustomDateRangeEditor';
+describe('CustomDateRangeEditor tests', function () {
+    var values = [new Date('2021-06-10'), new Date('2021-06-11')];
+    var defaultProps = { values: values, onChange: jest.fn() };
+    var setUp = function (props) {
+        if (props === void 0) { props = {}; }
+        var user = userEvent.setup();
+        var renderer = render(React.createElement(LocalizationProvider, { dateAdapter: AdapterMoment },
+            React.createElement(CustomDateRangeEditor, __assign({}, defaultProps, props))));
+        return __assign({ user: user }, renderer);
+    };
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should render main parts', function () {
+        setUp();
+        expect(screen.getByRole('textbox')).toBeInTheDocument();
+        expect(screen.queryByRole('presentation')).not.toBeInTheDocument();
+    });
+    it('should open DateRangePicker when clicked', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    user = setUp().user;
+                    return [4 /*yield*/, user.click(screen.getByRole('textbox'))];
+                case 1:
+                    _a.sent();
+                    expect(screen.getByRole('presentation')).toBeInTheDocument();
+                    expect(screen.getByRole('textbox', { name: 'From' })).toBeInTheDocument();
+                    expect(screen.getByRole('textbox', { name: 'To' })).toBeInTheDocument();
+                    expect(screen.getByRole('button', { name: 'Update' })).toBeInTheDocument();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should call onFocus on popover open', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var onFocusSpy, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    onFocusSpy = jest.fn();
+                    user = setUp({ onFocus: onFocusSpy }).user;
+                    return [4 /*yield*/, user.click(screen.getByRole('textbox'))];
+                case 1:
+                    _a.sent();
+                    expect(onFocusSpy).toBeCalledTimes(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should call props.onChange with dates when click on Update button', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var newValues, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    newValues = [new Date('05/05/2023'), new Date('05/06/2023')];
+                    user = setUp({ values: [] }).user;
+                    return [4 /*yield*/, user.click(screen.getByRole('textbox'))];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, user.type(screen.getByRole('textbox', { name: 'From' }), '05/05/2023')];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, user.type(screen.getByRole('textbox', { name: 'To' }), '05/06/2023')];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, user.click(screen.getByRole('button', { name: 'Update' }))];
+                case 4:
+                    _a.sent();
+                    expect(screen.queryByRole('presentation')).not.toBeInTheDocument();
+                    expect(defaultProps.onChange).toHaveBeenCalledWith(newValues);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not call props.onChange with values in case click on Back button', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    user = setUp({ values: [] }).user;
+                    return [4 /*yield*/, user.click(screen.getByRole('textbox'))];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, user.type(screen.getByRole('textbox', { name: 'From' }), '05/05/2023')];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, user.type(screen.getByRole('textbox', { name: 'To' }), '05/06/2023')];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, user.click(screen.getByRole('presentation').firstChild)];
+                case 4:
+                    _a.sent();
+                    expect(screen.queryByRole('presentation')).not.toBeInTheDocument();
+                    expect(defaultProps.onChange).not.toBeCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/esm/CustomDateRangeEditor/index.d.ts

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

package/esm/CustomDateRangeEditor/index.js

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

package/esm/CustomDateRangeEditor/styles.d.ts

@@ -0,0 +1 @@
+export declare const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"input" | "inputRoot" | "root" | "paper" | "dropdownIndicator" | "dateOptionLabel">;

package/esm/DataTenantBadge/DataTenantBadge.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    dataTenantId: string;
+    className?: string;
+};
+export declare const DataTenantBadge: ({ dataTenantId, className }: Props) => JSX.Element;
+export {};

package/esm/DataTenantBadge/DataTenantBadge.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import classnames from 'classnames';
+import { propEq, toUpper, slice, pipe, defaultTo, find, propOr, startsWith, ifElse } from 'ramda';
+import Typography from '@mui/material/Typography';
+import Tooltip from '@mui/material/Tooltip';
+import { useMdmDataTenants } from '../contexts/MdmModuleContext';
+import { useStyles } from './styles';
+var addDataTenantPrefix = function (label) { return "DT:".concat(slice(0, 1, label)); };
+export var DataTenantBadge = function (_a) {
+    var dataTenantId = _a.dataTenantId, className = _a.className;
+    var styles = useStyles({ dataTenantId: dataTenantId });
+    var dataTenants = useMdmDataTenants();
+    var dataTenant = pipe(defaultTo([]), find(propEq('id', dataTenantId)))(dataTenants);
+    var label = pipe(propOr('', 'label'), toUpper, ifElse(startsWith('DT:'), slice(0, 4), addDataTenantPrefix))(dataTenant);
+    var content = (React.createElement("div", { className: classnames(styles.root, className) },
+        React.createElement(Typography, { variant: "body2" }, label)));
+    var showTooltip = !!(dataTenant === null || dataTenant === void 0 ? void 0 : dataTenant.label);
+    if (!showTooltip) {
+        return content;
+    }
+    return (React.createElement(Tooltip, { "data-reltio-id": "reltio-data-tenant-bage-tooltip", title: dataTenant.label }, content));
+};

package/esm/DataTenantBadge/DataTenantBadge.test.d.ts

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

package/esm/DataTenantBadge/DataTenantBadge.test.js

@@ -0,0 +1,77 @@
+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 { MdmModuleProvider } from '../contexts/MdmModuleContext';
+import { DataTenantBadge } from './DataTenantBadge';
+var defaultDataTenants = [
+    {
+        id: 'uitest3',
+        name: 'DT_TEST',
+        label: 'DT:TEST'
+    },
+    {
+        id: 'hmcyo4cu',
+        name: 'withoutPrefix',
+        label: 'withoutPrefix'
+    },
+    {
+        id: 'uitest2',
+        name: 'DT_TEST'
+    }
+];
+var defaultMdmValues = {
+    dataTenants: defaultDataTenants
+};
+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(DataTenantBadge, __assign({}, props)), { wrapper: Providers });
+};
+describe('DataTenantBage tests', function () {
+    it('should pass className to root element correctly', function () {
+        setUp({ dataTenantId: 'uitest3', className: 'dataTenantBadge' });
+        expect(screen.getByLabelText('DT:TEST')).toHaveClass('dataTenantBadge');
+    });
+    it('should render correct label if dataTenantId exists in dataTenants', function () {
+        setUp({ dataTenantId: 'uitest3' });
+        screen.getByText('DT:T');
+    });
+    it('should render correct label if dataTenants is not exists', function () {
+        var mdmValues = { dataTenants: [] };
+        setUp({ dataTenantId: 'uitest3' }, mdmValues);
+        screen.getByText('DT:');
+    });
+    it('should render correct label if dataTenantId does not exist in dataTenants', function () {
+        setUp({ dataTenantId: 'notExistedTenantId' });
+        screen.getByText('DT:');
+    });
+    it('should render correct label if data tenant name does not start with "DT:"', function () {
+        setUp({ dataTenantId: 'hmcyo4cu' });
+        screen.getByText('DT:W');
+    });
+    it('should render correct tooltip if dataTenantId has a label', function () {
+        setUp({ dataTenantId: 'uitest3' });
+        screen.getByLabelText('DT:TEST');
+    });
+    it('should not render tooltip if dataTenant does not have a label property', function () {
+        setUp({ dataTenantId: 'uitest2' });
+        expect(screen.queryByTestId('reltio-data-tenant-bage-tooltip')).not.toBeInTheDocument();
+    });
+    it('should not render tooltip if dataTenantId does not exist in dataTenants', function () {
+        setUp({ dataTenantId: 'notExistedTenantId' });
+        expect(screen.queryByTestId('reltio-data-tenant-bage-tooltip')).not.toBeInTheDocument();
+    });
+});

package/esm/DataTenantBadge/index.d.ts

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

package/esm/DataTenantBadge/index.js

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

package/esm/DataTypeValue/DataTypeValue.d.ts

@@ -0,0 +1,13 @@
+export function DataTypeValue({ value, dataTypeDefinition, rich }: {
+    value?: any;
+    dataTypeDefinition: any;
+    rich?: boolean;
+}): JSX.Element;
+export namespace DataTypeValue {
+    namespace propTypes {
+        let value: PropTypes.Requireable<any>;
+        let dataTypeDefinition: PropTypes.Requireable<object>;
+        let rich: PropTypes.Requireable<boolean>;
+    }
+}
+import PropTypes from 'prop-types';

package/esm/DataTypeValue/DataTypeValue.js

@@ -0,0 +1,23 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import moment from 'moment';
+import { formatDataTypeValue, isAttributeValueLink, addProtocolToLink } from '@reltio/mdm-sdk';
+import Link from '@mui/material/Link';
+import SearchHighlighter from '../components/SearchHighlighter/SearchHighlighter';
+import { useMdmAttributesPresentation, useMdmDateMask, useMdmDateTimeMask } from '../contexts/MdmModuleContext';
+export var DataTypeValue = function (_a) {
+    var _b = _a.value, value = _b === void 0 ? null : _b, dataTypeDefinition = _a.dataTypeDefinition, _c = _a.rich, rich = _c === void 0 ? true : _c;
+    var localeDateFormat = moment.localeData().longDateFormat('L');
+    var localeTimeFormat = moment.localeData().longDateFormat('LTS');
+    var attributesPresentation = useMdmAttributesPresentation();
+    var dateMask = useMdmDateMask() || localeDateFormat;
+    var dateTimeMask = useMdmDateTimeMask() || localeDateFormat + ' ' + localeTimeFormat;
+    var formattedValue = formatDataTypeValue({ attributesPresentation: attributesPresentation, dataTypeDefinition: dataTypeDefinition, dateMask: dateMask, dateTimeMask: dateTimeMask }, value);
+    return rich && isAttributeValueLink(dataTypeDefinition, value) ? (React.createElement(Link, { target: "_blank", href: addProtocolToLink(formattedValue), underline: "none" },
+        React.createElement(SearchHighlighter, { text: formattedValue }))) : (React.createElement(SearchHighlighter, { text: formattedValue }));
+};
+DataTypeValue.propTypes = {
+    value: PropTypes.any,
+    dataTypeDefinition: PropTypes.object,
+    rich: PropTypes.bool
+};

package/esm/DataTypeValue/DataTypeValue.test.d.ts

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