@reltio/components 1.4.1819 → 1.4.1821

package/esm/InlineSimpleAttributeEditor/InlineSimpleAttributeEditor.test.js

@@ -14,8 +14,8 @@ import { shallow } from 'enzyme';
 import { act } from 'react-dom/test-utils';
 import { DataTypes } from '@reltio/mdm-sdk';
 import Popover from '@mui/material/Popover';
+import { DataTypeValueEditor } from '../DataTypeValueEditor';
 import { InlineSimpleAttributeEditor } from './InlineSimpleAttributeEditor';
-import DataTypeValueEditor from '../components/editors/DataTypeValueEditor/DataTypeValueEditor';
 describe('InlineSimpleAttributeEditor', function () {
     var attributeType = {
         uri: 'configuration/entityTypes/HCP/attributes/Simple',

package/esm/LookupEditor/LookupEditor.d.ts

@@ -0,0 +1,33 @@
+export function LookupEditor({ multiple, value, lookupCode: lookupTypeCode, lookups, onChange, getLookups, ...otherProps }: {
+    [x: string]: any;
+    multiple: any;
+    value: any;
+    lookupCode: any;
+    lookups: any;
+    onChange: any;
+    getLookups: any;
+}): JSX.Element;
+export namespace LookupEditor {
+    namespace propTypes {
+        let multiple: PropTypes.Requireable<boolean>;
+        let value: PropTypes.Requireable<NonNullable<PropTypes.InferProps<{
+            value: PropTypes.Requireable<string>;
+            lookupCode: PropTypes.Requireable<string>;
+        }> | PropTypes.InferProps<{
+            value: PropTypes.Requireable<string>;
+            lookupCode: PropTypes.Requireable<string>;
+        }>[]>>;
+        let lookupCode: PropTypes.Validator<string>;
+        let lookups: PropTypes.Validator<{
+            [x: string]: {
+                [x: string]: PropTypes.InferProps<{
+                    displayName: PropTypes.Requireable<string>;
+                    parent: PropTypes.Requireable<string>;
+                }>;
+            };
+        }>;
+        let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        let getLookups: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+import PropTypes from 'prop-types';

package/esm/LookupEditor/LookupEditor.js

@@ -0,0 +1,53 @@
+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 PropTypes from 'prop-types';
+import React, { useEffect } from 'react';
+import { SimpleLookupType, LookupValueType } from '@reltio/mdm-sdk';
+import { always, defaultTo, isEmpty, map, path, pipe, pluck, prop, propEq } from 'ramda';
+import { buildLookupEntries } from './helpers';
+import { GroupedDropDownEditor } from './components/GroupedDropDownEditor';
+export var LookupEditor = function (_a) {
+    var multiple = _a.multiple, value = _a.value, lookupTypeCode = _a.lookupCode, lookups = _a.lookups, onChange = _a.onChange, getLookups = _a.getLookups, otherProps = __rest(_a, ["multiple", "value", "lookupCode", "lookups", "onChange", "getLookups"]);
+    var codeToLookup = function (lookupCode) { return ({
+        lookupCode: lookupCode,
+        value: path([lookupTypeCode, lookupCode, 'displayName'], lookups)
+    }); };
+    useEffect(function () {
+        var _a;
+        if (isEmpty(lookups) && getLookups) {
+            (_a = getLookups()) === null || _a === void 0 ? void 0 : _a.catch(function () { });
+        }
+    }, [lookups, getLookups]);
+    var entries = buildLookupEntries(lookupTypeCode, lookups); // TODO: this code could be not valid if lookups are not loaded
+    var commonProps = __assign(__assign({}, otherProps), { multiple: multiple, entries: entries });
+    value = defaultTo(multiple ? [] : {}, value);
+    return multiple ? (React.createElement(GroupedDropDownEditor, __assign({}, commonProps, { value: pluck('lookupCode', value), getValuePlaceholder: function (lookupCode) { return value.find(propEq('lookupCode', lookupCode)).value; }, onChange: pipe(map(codeToLookup), onChange) }))) : (React.createElement(GroupedDropDownEditor, __assign({}, commonProps, { value: prop('lookupCode', value), getValuePlaceholder: always(prop('value', value)), onChange: pipe(codeToLookup, onChange) })));
+};
+LookupEditor.propTypes = {
+    multiple: PropTypes.bool,
+    value: PropTypes.oneOfType([LookupValueType, PropTypes.arrayOf(LookupValueType)]),
+    lookupCode: PropTypes.string.isRequired,
+    lookups: PropTypes.objectOf(PropTypes.objectOf(SimpleLookupType)).isRequired,
+    onChange: PropTypes.func,
+    getLookups: PropTypes.func
+};

package/esm/LookupEditor/LookupEditor.test.d.ts

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

package/esm/LookupEditor/LookupEditor.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 { mount, shallow } from 'enzyme';
+import * as helpers from './helpers';
+import { GroupedDropDownEditor } from './components/GroupedDropDownEditor';
+import { LookupEditor } from './LookupEditor';
+describe('LookupEditor', function () {
+    var props;
+    beforeAll(function () {
+        props = {
+            lookupCode: 'MultiLevel',
+            lookups: { MultiLevel: { L1: {} } }
+        };
+    });
+    it('should render GroupedDropDownEditor with entries built with buildLookupEntries', function () {
+        var entries = [{ value: 'L1', label: 'L1' }];
+        var value = { lookupCode: 'L1', value: 'L1' };
+        jest.spyOn(helpers, 'buildLookupEntries').mockReturnValue(entries);
+        var wrapper = shallow(React.createElement(LookupEditor, __assign({ value: value }, props)));
+        var dropDown = wrapper.find(GroupedDropDownEditor);
+        expect(dropDown).toHaveLength(1);
+        expect(dropDown.prop('entries')).toEqual(entries);
+        expect(dropDown.prop('value')).toBe(value.lookupCode);
+        expect(helpers.buildLookupEntries).toBeCalledWith(props.lookupCode, props.lookups);
+        helpers.buildLookupEntries.mockRestore();
+    });
+    it('should load lookups if lookups are not available', function () {
+        jest.spyOn(helpers, 'buildLookupEntries').mockReturnValue([]);
+        var getLookups = jest.fn();
+        mount(React.createElement(LookupEditor, { getLookups: getLookups, lookups: {}, lookupCode: "test" }));
+        expect(getLookups).toHaveBeenCalled();
+        helpers.buildLookupEntries.mockRestore();
+    });
+    it('should not load lookups if lookups are available', function () {
+        jest.spyOn(helpers, 'buildLookupEntries').mockReturnValue([]);
+        var getLookups = jest.fn();
+        mount(React.createElement(LookupEditor, __assign({ getLookups: getLookups }, props)));
+        expect(getLookups).not.toHaveBeenCalled();
+        helpers.buildLookupEntries.mockRestore();
+    });
+    describe('single mode', function () {
+        it('should show lookup value as label if lookups do not contain specified lookupCode', function () {
+            var value = 'Placeholder';
+            var wrapper = mount(React.createElement(LookupEditor, __assign({ value: { value: value, lookupCode: '1' } }, props)));
+            expect(wrapper.text()).toBe(value);
+        });
+        it('should call props.onChange with displayName and lookupCode', function () {
+            var onChange = jest.fn();
+            var wrapper = shallow(React.createElement(LookupEditor, __assign({ onChange: onChange }, props)));
+            wrapper.find(GroupedDropDownEditor).simulate('change', 'L1');
+            expect(onChange).toBeCalledWith({ lookupCode: 'L1', value: undefined });
+        });
+    });
+    describe('multiple mode', function () {
+        it('should show lookup value as label if lookups do not contain specified lookupCode', function () {
+            var value = 'Placeholder';
+            var wrapper = mount(React.createElement(LookupEditor, __assign({ multiple: true, value: [{ value: value, lookupCode: '1' }] }, props)));
+            expect(wrapper.text()).toBe(value);
+        });
+        it('should call props.onChange with displayName and lookupCode', function () {
+            var onChange = jest.fn();
+            var wrapper = shallow(React.createElement(LookupEditor, __assign({ multiple: true, onChange: onChange }, props)));
+            wrapper.find(GroupedDropDownEditor).simulate('change', ['L1']);
+            expect(onChange).toBeCalledWith([{ lookupCode: 'L1', value: undefined }]);
+        });
+    });
+});

package/esm/LookupEditor/components/GroupedDropDownEditor/GroupedDropDownEditor.d.ts

@@ -0,0 +1,21 @@
+export const MENU_ITEM_OFFSET: 25;
+export function GroupedDropDownEditor({ value, entries, classes, ...otherProps }: {
+    [x: string]: any;
+    value: any;
+    entries: any;
+    classes: any;
+}): JSX.Element;
+export namespace GroupedDropDownEditor {
+    namespace propTypes {
+        let value: PropTypes.Requireable<NonNullable<NonNullable<string | number | object>>>;
+        let entries: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            value: PropTypes.Validator<NonNullable<NonNullable<string | number | object>>>;
+            label: PropTypes.Requireable<string>;
+        }> | PropTypes.InferProps<{
+            label: PropTypes.Validator<string>;
+            values: PropTypes.Validator<object[]>;
+        }>>[]>;
+        let classes: PropTypes.Requireable<object>;
+    }
+}
+import PropTypes from 'prop-types';

package/esm/LookupEditor/components/GroupedDropDownEditor/GroupedDropDownEditor.js

@@ -0,0 +1,54 @@
+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 from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import i18n from 'ui-i18n';
+import { isNil, pipe, prop } from 'ramda';
+import { wrapInArrayIfNeeded } from '@reltio/mdm-sdk';
+import CheckIcon from '@mui/icons-material/Check';
+import MenuItem from '@mui/material/MenuItem';
+import { DropDownEntryType, DropDownGroupEntryType, SelectValueType } from '../../../constants/prop-types';
+import MultipliableSelect from '../../../components/MultipliableSelect/MultipliableSelect';
+import { findEntryByValue, flattenGroupedEntries } from './helpers';
+import { useStyles } from './styles';
+export var MENU_ITEM_OFFSET = 25;
+export var GroupedDropDownEditor = function (_a) {
+    var value = _a.value, entries = _a.entries, classes = _a.classes, otherProps = __rest(_a, ["value", "entries", "classes"]);
+    var flattenedEntries = flattenGroupedEntries(entries);
+    var selectedValues = isNil(value) ? [] : wrapInArrayIfNeeded(value);
+    var styles = useStyles();
+    return (React.createElement(MultipliableSelect, __assign({ MenuProps: {
+            disableAutoFocusItem: true
+        }, classes: __assign(__assign({}, classes), { root: classnames(styles.root, prop('root', classes)), icon: classnames(styles.icon, prop('icon', classes)) }) }, otherProps, { value: value, getValueLabel: pipe(findEntryByValue(flattenedEntries), prop('label')) }), flattenedEntries.length > 0 ? (flattenedEntries.map(function (_a, index) {
+        var value = _a.value, label = _a.label, depth = _a.depth, isGroup = _a.isGroup;
+        return (React.createElement(MenuItem, { key: index, disabled: isGroup, value: value, style: { paddingLeft: "".concat((depth + 1) * MENU_ITEM_OFFSET, "px") } },
+            selectedValues.includes(value) && React.createElement(CheckIcon, { className: styles.checkIcon }),
+            label || value.toString()));
+    })) : (React.createElement(MenuItem, { className: styles.emptyLabel, disabled: true }, i18n.text('No results found')))));
+};
+GroupedDropDownEditor.propTypes = {
+    value: PropTypes.oneOfType([SelectValueType, PropTypes.arrayOf(SelectValueType)]),
+    entries: PropTypes.arrayOf(PropTypes.oneOfType([DropDownEntryType, DropDownGroupEntryType])).isRequired,
+    classes: PropTypes.object
+};

package/esm/LookupEditor/components/GroupedDropDownEditor/GroupedDropDownEditor.test.d.ts

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

package/esm/LookupEditor/components/GroupedDropDownEditor/GroupedDropDownEditor.test.js

@@ -0,0 +1,37 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import CheckIcon from '@mui/icons-material/Check';
+import MenuItem from '@mui/material/MenuItem';
+import MultipliableSelect from '../../../components/MultipliableSelect/MultipliableSelect';
+import { GroupedDropDownEditor, MENU_ITEM_OFFSET } from './GroupedDropDownEditor';
+describe('GroupedDropDownEditor', function () {
+    it('should render MultipliableSelect with entries as options', function () {
+        var entries = [{ label: 'L1', values: [{ value: 'L2' }] }];
+        var value = 'L2';
+        var wrapper = shallow(React.createElement(GroupedDropDownEditor, { entries: entries, value: value }));
+        expect(wrapper.find(MultipliableSelect).prop('value')).toBe(value);
+        var items = wrapper.find(MenuItem);
+        expect(items.at(0).prop('disabled')).toBe(true);
+        expect(items.at(0).text()).toEqual('L1');
+        expect(items.at(0).find(CheckIcon)).toHaveLength(0);
+        expect(items.at(0).prop('style').paddingLeft).toBe("".concat(MENU_ITEM_OFFSET, "px"));
+        expect(items.at(1).prop('disabled')).toBe(undefined);
+        expect(items.at(1).text()).toEqual('L2');
+        expect(items.at(1).find(CheckIcon)).toHaveLength(1);
+        expect(items.at(1).prop('style').paddingLeft).toBe("".concat(MENU_ITEM_OFFSET * 2, "px"));
+    });
+    it('should call props.onChange with a new value', function () {
+        var entries = [{ label: 'L1', values: [{ value: 'L2' }] }];
+        var onChange = jest.fn(), value = 'L2';
+        var wrapper = shallow(React.createElement(GroupedDropDownEditor, { value: '', entries: entries, onChange: onChange }));
+        wrapper.find(MultipliableSelect).simulate('change', value);
+        expect(onChange).toBeCalledWith(value);
+    });
+    it('should render MultipliableSelect with empty entries', function () {
+        var wrapper = shallow(React.createElement(GroupedDropDownEditor, { entries: [] }));
+        expect(wrapper.find(MultipliableSelect)).toHaveLength(1);
+        var items = wrapper.find(MenuItem);
+        expect(items.at(0).prop('disabled')).toBe(true);
+        expect(items.at(0).text()).toEqual('No results found');
+    });
+});

package/esm/LookupEditor/components/GroupedDropDownEditor/helpers.js

@@ -0,0 +1,33 @@
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { chain, curry, has } from 'ramda';
+var isGroupEntry = has('values');
+var flattenEntry = curry(function (depth, entry) {
+    return isGroupEntry(entry)
+        ? __spreadArray([{ label: entry.label, depth: depth, isGroup: true }], chain(flattenEntry(depth + 1), entry.values), true) : __assign(__assign({}, entry), { depth: depth });
+});
+export var flattenGroupedEntries = chain(flattenEntry(0));
+export var findEntryByValue = curry(function (entries, _value) {
+    return entries.find(function (_a) {
+        var isGroup = _a.isGroup, value = _a.value;
+        return !isGroup && value === _value;
+    });
+});

package/esm/LookupEditor/components/GroupedDropDownEditor/helpers.test.d.ts

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

package/esm/LookupEditor/components/GroupedDropDownEditor/helpers.test.js

@@ -0,0 +1,34 @@
+import { flattenGroupedEntries } from './helpers';
+var groupEntry = function (label) {
+    var values = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        values[_i - 1] = arguments[_i];
+    }
+    return ({ label: label, values: values });
+};
+var entry = function (value) { return ({ value: value }); };
+var groupOpt = function (label, depth) { return ({ label: label, depth: depth, isGroup: true }); };
+var entryOpt = function (value, depth) { return ({ value: value, depth: depth }); };
+describe('entries helpers', function () {
+    describe('flattenGroupedEntries', function () {
+        it('should return empty array for empty entries', function () {
+            expect(flattenGroupedEntries([])).toEqual([]);
+        });
+        it('should flatten grouped entries with depth assignment', function () {
+            expect(flattenGroupedEntries([
+                groupEntry('L1 1', groupEntry('L2 1', entry('L3 1'), entry('L3 2')), entry('L2 2')),
+                groupEntry('L1 2', entry('L2 3')),
+                entry('L1 3')
+            ])).toEqual([
+                groupOpt('L1 1', 0),
+                groupOpt('L2 1', 1),
+                entryOpt('L3 1', 2),
+                entryOpt('L3 2', 2),
+                entryOpt('L2 2', 1),
+                groupOpt('L1 2', 0),
+                entryOpt('L2 3', 1),
+                entryOpt('L1 3', 0)
+            ]);
+        });
+    });
+});

package/esm/LookupEditor/components/GroupedDropDownEditor/index.d.ts

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

package/esm/LookupEditor/components/GroupedDropDownEditor/index.js

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

package/esm/LookupEditor/components/GroupedDropDownEditor/styles.d.ts

@@ -0,0 +1 @@
+export const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"icon" | "root" | "checkIcon" | "emptyLabel">;

package/esm/LookupEditor/components/GroupedDropDownEditor/styles.js

@@ -0,0 +1,17 @@
+import { makeStyles } from '@mui/styles';
+export var useStyles = makeStyles({
+    root: {
+        paddingRight: '48px !important'
+    },
+    icon: {
+        right: '12px'
+    },
+    checkIcon: {
+        transform: 'scale(.7)',
+        marginLeft: '-25px',
+        position: 'absolute'
+    },
+    emptyLabel: {
+        padding: '4px 16px'
+    }
+});

package/esm/LookupEditor/helpers.js

@@ -0,0 +1,29 @@
+import { ascend, assocPath, path, prop, curry, useWith } from 'ramda';
+import { getLookupLabel } from '@reltio/mdm-sdk';
+var LOOKUP_URI_SEPARATOR = '.';
+var splitOnce = curry(function (separator, string) {
+    var _a = string.split(separator), first = _a[0], other = _a.slice(1);
+    return [first, other.join(separator)];
+});
+// eslint-disable-next-line react-hooks/rules-of-hooks
+var getLookupByUri = useWith(path, [splitOnce(LOOKUP_URI_SEPARATOR)]);
+var byLabel = ascend(prop('label'));
+export var buildLookupEntries = function (lookupTypeCode, lookups) {
+    var getLookupPath = function (uri) {
+        var parent = getLookupByUri(uri, lookups).parent;
+        return parent ? getLookupPath(parent).concat(uri) : [uri];
+    };
+    var buildEntry = function (_a) {
+        var uri = _a[0], value = _a[1];
+        var lookup = getLookupByUri(uri, lookups);
+        var _b = splitOnce(LOOKUP_URI_SEPARATOR, uri), code = _b[1];
+        var label = getLookupLabel(code, lookup.displayName);
+        return lookup === value ? { label: label, value: code } : { label: label, values: buildEntries(value) };
+    };
+    var buildEntries = function (value) { return Object.entries(value).map(buildEntry).sort(byLabel); };
+    var hierarchy = Object.entries(lookups[lookupTypeCode] || []).reduce(function (acc, _a) {
+        var code = _a[0], value = _a[1];
+        return assocPath(getLookupPath("".concat(lookupTypeCode).concat(LOOKUP_URI_SEPARATOR).concat(code)), value, acc);
+    }, {});
+    return buildEntries(hierarchy);
+};

package/esm/LookupEditor/helpers.test.d.ts

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

package/esm/LookupEditor/helpers.test.js

@@ -0,0 +1,103 @@
+import { buildLookupEntries } from './helpers';
+describe('helpers', function () {
+    describe('buildLookupEntries', function () {
+        it('should return empty array for empty lookup type', function () {
+            expect(buildLookupEntries('type', { type: {} })).toEqual([]);
+        });
+        it('should return regular entries for lookups with no parents', function () {
+            expect(buildLookupEntries('type', { type: { t1: { displayName: 't1' } } })).toEqual([{ value: 't1', label: 't1' }]);
+        });
+        it('should return entry with combined label if lookup code differs from displayName', function () {
+            expect(buildLookupEntries('type', { type: { t1: { displayName: 'name-t1' } } })).toEqual([
+                { value: 't1', label: 'name-t1 (t1)' }
+            ]);
+        });
+        it('should return entry with code as label if displayName is empty', function () {
+            expect(buildLookupEntries('type', { type: { t1: { displayName: '' } } })).toEqual([{ value: 't1', label: 't1' }]);
+        });
+        it('should return grouped entries for lookups with parents', function () {
+            expect(buildLookupEntries('type', {
+                type: {
+                    t1: { displayName: 't1', parent: 'parentType.pt1' },
+                    t2: { displayName: 't2', parent: 'parentType.pt2' }
+                },
+                parentType: {
+                    pt1: { displayName: 'pt1', parent: 'grandParentType.gpt1' },
+                    pt2: { displayName: 'pt2', parent: 'grandParentType.gpt1' }
+                },
+                grandParentType: {
+                    gpt1: { displayName: 'gpt1' }
+                }
+            })).toEqual([
+                {
+                    label: 'gpt1',
+                    values: [
+                        { label: 'pt1', values: [{ value: 't1', label: 't1' }] },
+                        { label: 'pt2', values: [{ value: 't2', label: 't2' }] }
+                    ]
+                }
+            ]);
+        });
+        it('should return correct entries if lookup has special symbols in name', function () {
+            var _a, _b, _c;
+            expect(buildLookupEntries('type', {
+                type: (_a = {},
+                    _a['Test Country U.S.'] = { displayName: 'Test Country U.S.', parent: 'parentType.Parent 1.2.3' },
+                    _a['With. symbols/.12$%'] = { displayName: 'With. symbols/.12$%', parent: 'parentType.Parent 3/2/1' },
+                    _a),
+                parentType: (_b = {},
+                    _b['Parent 1.2.3'] = { displayName: 'Parent 1.2.3', parent: 'grandParentType.GrandParent.' },
+                    _b['Parent 3/2/1'] = { displayName: 'Parent 3/2/1', parent: 'grandParentType.GrandParent.' },
+                    _b),
+                grandParentType: (_c = {},
+                    _c['GrandParent.'] = { displayName: 'GrandParent.' },
+                    _c)
+            })).toEqual([
+                {
+                    label: 'GrandParent.',
+                    values: [
+                        { label: 'Parent 1.2.3', values: [{ value: 'Test Country U.S.', label: 'Test Country U.S.' }] },
+                        { label: 'Parent 3/2/1', values: [{ value: 'With. symbols/.12$%', label: 'With. symbols/.12$%' }] }
+                    ]
+                }
+            ]);
+        });
+        it('should sort entries by label', function () {
+            expect(buildLookupEntries('type', {
+                type: {
+                    t1: { displayName: 'E', parent: 'parentType.pt1' },
+                    t2: { displayName: 'D', parent: 'parentType.pt1' },
+                    t3: { displayName: 'G', parent: 'parentType.pt2' },
+                    t4: { displayName: 'F', parent: 'parentType.pt2' }
+                },
+                parentType: {
+                    pt1: { displayName: 'C', parent: 'grandParentType.gpt1' },
+                    pt2: { displayName: 'B', parent: 'grandParentType.gpt1' }
+                },
+                grandParentType: {
+                    gpt1: { displayName: 'A' }
+                }
+            })).toEqual([
+                {
+                    label: 'A (gpt1)',
+                    values: [
+                        {
+                            label: 'B (pt2)',
+                            values: [
+                                { value: 't4', label: 'F (t4)' },
+                                { value: 't3', label: 'G (t3)' }
+                            ]
+                        },
+                        {
+                            label: 'C (pt1)',
+                            values: [
+                                { value: 't2', label: 'D (t2)' },
+                                { value: 't1', label: 'E (t1)' }
+                            ]
+                        }
+                    ]
+                }
+            ]);
+        });
+    });
+});

package/esm/LookupEditor/index.d.ts

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

package/esm/LookupEditor/index.js

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

package/esm/MoreAttributesButton/MoreAttributesButton.js

@@ -8,7 +8,7 @@ import Typography from '@mui/material/Typography';
 import AddIcon from '@mui/icons-material/Add';
 import { AttributeListItem } from '../AttributeListItem';
 import SelectionPopup from '../components/SelectionPopup/SelectionPopup';
-import Highlighter from '../components/Highlighter/Highlighter';
+import { Highlighter } from '../Highlighter';
 import { useKeyboardNavigation } from '../components/SelectionPopup/helpers';
 import VirtualGroupedList from '../components/VirtualGroupedList/VirtualGroupedList';
 import { useMoreAttributesItems } from './useMoreAttributesItems';

package/esm/MoreAttributesButton/MoreAttributesButton.test.js

@@ -19,7 +19,7 @@ import MenuItem from '@mui/material/MenuItem';
 import AddIcon from '@mui/icons-material/Add';
 import { AttributeListItem } from '../AttributeListItem/';
 import SelectionPopup from '../components/SelectionPopup/SelectionPopup';
-import Highlighter from '../components/Highlighter/Highlighter';
+import { Highlighter } from '../Highlighter';
 import Marginator from '../components/Marginator/Marginator';
 import { useMdmAttributesSortingStrategy } from '../contexts/MdmModuleContext';
 import { attributesList, attributesListForParent, parent } from './attributes.test-data';

package/esm/MoreAttributesButton/styles.d.ts

@@ -1 +1 @@
-export declare const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"dense" | "icon" | "moreButton" | "buttonLabel" | "popupContainer" | "moreAttributes" | "moreAttributesPopup" | "subHeader" | "noResultsCaptionContainer">;
+export declare const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"dense" | "icon" | "buttonLabel" | "moreButton" | "moreAttributes" | "popupContainer" | "moreAttributesPopup" | "subHeader" | "noResultsCaptionContainer">;

package/esm/MultiValueChip/MultiValueChip.d.ts

@@ -0,0 +1,17 @@
+export function MultiValueChip(props: any): JSX.Element;
+export namespace MultiValueChip {
+    namespace propTypes {
+        let children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let data: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            value: PropTypes.Requireable<string>;
+            label: PropTypes.Requireable<string>;
+            number: PropTypes.Requireable<number>;
+        }>>>;
+        let removeProps: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            onClick: PropTypes.Validator<(...args: any[]) => any>;
+            onMouseDown: PropTypes.Validator<(...args: any[]) => any>;
+            onTouchEnd: PropTypes.Validator<(...args: any[]) => any>;
+        }>>>;
+    }
+}
+import PropTypes from 'prop-types';

package/esm/MultiValueChip/MultiValueChip.js

@@ -0,0 +1,33 @@
+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 PropTypes from 'prop-types';
+import { prop } from 'ramda';
+import CancelIcon from '@mui/icons-material/Cancel';
+import ValueChip from '../components/ValueChip/ValueChip';
+export var MultiValueChip = function (props) {
+    var children = props.children, data = props.data, removeProps = props.removeProps;
+    return (React.createElement(ValueChip, { tabIndex: -1, label: children, count: prop('formattedNumber', data), onDelete: removeProps.onClick, deleteIcon: React.createElement(CancelIcon, __assign({}, props.removeProps)) }));
+};
+MultiValueChip.propTypes = {
+    children: PropTypes.node,
+    data: PropTypes.shape({
+        value: PropTypes.string,
+        label: PropTypes.string,
+        number: PropTypes.number
+    }).isRequired,
+    removeProps: PropTypes.shape({
+        onClick: PropTypes.func.isRequired,
+        onMouseDown: PropTypes.func.isRequired,
+        onTouchEnd: PropTypes.func.isRequired
+    }).isRequired
+};

package/esm/MultiValueChip/index.d.ts

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

package/esm/MultiValueChip/index.js

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

package/esm/NumberEditor/NumberEditor.d.ts

@@ -0,0 +1,16 @@
+import { NumberFormat as TNumberFormat } from '@reltio/mdm-sdk';
+import { TextFieldProps } from '@mui/material/TextField';
+type Props = Omit<TextFieldProps, 'onChange' | 'value'> & {
+    multiple?: boolean;
+    integer?: boolean;
+    format?: TNumberFormat;
+    inputProps?: Record<string, unknown>;
+    InputProps?: Record<string, unknown>;
+    InputLabelProps?: Record<string, unknown>;
+    value: string | number | string[] | number[] | undefined;
+    onChange: (value: string | number | string[] | number[]) => void;
+    className?: string;
+    label?: string;
+};
+export declare const NumberEditor: ({ integer, format, inputProps, InputProps, ...otherProps }: Props) => JSX.Element;
+export {};