@reltio/components 1.4.701 → 1.4.705

package/core/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);

package/core/utils.js

@@ -0,0 +1,54 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJSON = exports.toggleSortOrder = exports.createStandardAction = exports.isIE = exports.mergeClasses = exports.EmptyStub = exports.noop = exports.stopPropagation = exports.getChecked = exports.getValue = void 0;
+var ramda_1 = require("ramda");
+var classnames_1 = __importDefault(require("classnames"));
+var getValue = function (e) { return e.target.value; };
+exports.getValue = getValue;
+var getChecked = function (e) { return e.target.checked; };
+exports.getChecked = getChecked;
+var stopPropagation = function (e) { return e.stopPropagation(); };
+exports.stopPropagation = stopPropagation;
+var noop = function () { };
+exports.noop = noop;
+var EmptyStub = function () { return null; };
+exports.EmptyStub = EmptyStub;
+var mergeClasses = function (classes, other) {
+    return ramda_1.union(Object.keys(classes), Object.keys(other)).reduce(function (merged, key) {
+        var _a;
+        return (__assign(__assign({}, merged), (_a = {}, _a[key] = classnames_1.default(classes[key], other[key]), _a)));
+    }, {});
+};
+exports.mergeClasses = mergeClasses;
+var isIE = function () { return ramda_1.compose(ramda_1.either(ramda_1.includes('MSIE '), ramda_1.includes('Trident/')), ramda_1.path(['navigator', 'userAgent']))(window); };
+exports.isIE = isIE;
+var createStandardAction = function (type) { return function (payload) { return ({
+    type: type,
+    payload: payload
+}); }; };
+exports.createStandardAction = createStandardAction;
+var toggleSortOrder = function (order) { return (order === 'asc' ? 'desc' : 'asc'); };
+exports.toggleSortOrder = toggleSortOrder;
+var parseJSON = function (value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+exports.parseJSON = parseJSON;

package/hooks/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConfigPermissions = exports.useWhyDidYouUpdate = exports.useUsers = exports.useSavedState = exports.useSafePromise = exports.useRunOnceAfterValueInitialization = exports.useRelationsLoader = exports.useRelationTypeSelector = exports.usePrevious = exports.useDidUpdateEffect = exports.useCollaboration = exports.useAsyncMount = exports.useActions = void 0;
+var useActions_1 = require("./useActions");
+Object.defineProperty(exports, "useActions", { enumerable: true, get: function () { return useActions_1.useActions; } });
+var useAsyncMount_1 = require("./useAsyncMount");
+Object.defineProperty(exports, "useAsyncMount", { enumerable: true, get: function () { return useAsyncMount_1.useAsyncMount; } });
+var useCollaboration_1 = require("./useCollaboration");
+Object.defineProperty(exports, "useCollaboration", { enumerable: true, get: function () { return useCollaboration_1.useCollaboration; } });
+var useDidUpdateEffect_1 = require("./useDidUpdateEffect");
+Object.defineProperty(exports, "useDidUpdateEffect", { enumerable: true, get: function () { return useDidUpdateEffect_1.useDidUpdateEffect; } });
+var usePrevious_1 = require("./usePrevious");
+Object.defineProperty(exports, "usePrevious", { enumerable: true, get: function () { return usePrevious_1.usePrevious; } });
+var useRelationTypeSelector_1 = require("./useRelationTypeSelector");
+Object.defineProperty(exports, "useRelationTypeSelector", { enumerable: true, get: function () { return useRelationTypeSelector_1.useRelationTypeSelector; } });
+var useRelationsLoader_1 = require("./useRelationsLoader");
+Object.defineProperty(exports, "useRelationsLoader", { enumerable: true, get: function () { return useRelationsLoader_1.useRelationsLoader; } });
+var useRunOnceAfterValueInitialization_1 = require("./useRunOnceAfterValueInitialization");
+Object.defineProperty(exports, "useRunOnceAfterValueInitialization", { enumerable: true, get: function () { return useRunOnceAfterValueInitialization_1.useRunOnceAfterValueInitialization; } });
+var useSafePromise_1 = require("./useSafePromise");
+Object.defineProperty(exports, "useSafePromise", { enumerable: true, get: function () { return useSafePromise_1.useSafePromise; } });
+var useSavedState_1 = require("./useSavedState");
+Object.defineProperty(exports, "useSavedState", { enumerable: true, get: function () { return useSavedState_1.useSavedState; } });
+var useUsers_1 = require("./useUsers");
+Object.defineProperty(exports, "useUsers", { enumerable: true, get: function () { return useUsers_1.useUsers; } });
+var useWhyDidYouUpdate_1 = require("./useWhyDidYouUpdate");
+Object.defineProperty(exports, "useWhyDidYouUpdate", { enumerable: true, get: function () { return useWhyDidYouUpdate_1.useWhyDidYouUpdate; } });
+var useConfigPermissions_1 = require("./useConfigPermissions");
+Object.defineProperty(exports, "useConfigPermissions", { enumerable: true, get: function () { return useConfigPermissions_1.useConfigPermissions; } });

package/hooks/useActions.js

@@ -0,0 +1,27 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useActions = void 0;
+var react_1 = require("react");
+var ramda_1 = require("ramda");
+var useActions = function (_a) {
+    var actions = _a.actions, dispatch = _a.dispatch;
+    return react_1.useMemo(function () {
+        return Object.entries(actions).reduce(function (acc, _a) {
+            var _b;
+            var actionName = _a[0], actionCreator = _a[1];
+            return __assign(__assign({}, acc), (_b = {}, _b[actionName] = ramda_1.pipe(actionCreator, dispatch), _b));
+        }, {});
+    }, [dispatch, actions]);
+};
+exports.useActions = useActions;

package/hooks/useAsyncMount.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAsyncMount = void 0;
+var react_1 = require("react");
+var AsyncMountContext_1 = require("../contexts/AsyncMountContext");
+var queueSize = 0;
+var useAsyncMount = function () {
+    var isFirstRunRef = react_1.useRef(true);
+    var _a = react_1.useContext(AsyncMountContext_1.AsyncMountContext), enabled = _a.enabled, _b = _a.queueSizeThreshold, queueSizeThreshold = _b === void 0 ? 0 : _b;
+    var _c = react_1.useState(!enabled || (enabled && queueSize < queueSizeThreshold)), shouldMount = _c[0], setShouldMount = _c[1];
+    if (isFirstRunRef.current) {
+        queueSize++;
+    }
+    var timerRef = react_1.useRef();
+    react_1.useEffect(function () {
+        queueSize--;
+        if (!shouldMount) {
+            timerRef.current = setTimeout(function () {
+                setShouldMount(true);
+            }, 0);
+            return function () { return clearTimeout(timerRef.current); };
+        }
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    isFirstRunRef.current = false;
+    return shouldMount;
+};
+exports.useAsyncMount = useAsyncMount;

package/hooks/useCollaboration.js

@@ -0,0 +1,151 @@
+"use strict";
+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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCollaboration = void 0;
+var react_1 = require("react");
+var react_redux_1 = require("react-redux");
+var ramda_1 = require("ramda");
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var mdm_module_1 = __importDefault(require("@reltio/mdm-module"));
+var defaultObjectIds = [];
+var useCollaboration = function (objectIds) {
+    if (objectIds === void 0) { objectIds = defaultObjectIds; }
+    var entity = react_redux_1.useSelector(mdm_module_1.default.selectors.getEntity);
+    var tenant = react_redux_1.useSelector(mdm_module_1.default.selectors.getTenant);
+    var collaborationPath = react_redux_1.useSelector(mdm_module_1.default.selectors.getCollaborationPath);
+    var isCollaborationEnabled = react_redux_1.useSelector(mdm_module_1.default.selectors.isCollaborationEnabled);
+    var _a = react_1.useState(null), commentsMap = _a[0], setCommentsMap = _a[1];
+    var _b = react_1.useState(null), currentComment = _b[0], setCurrentComment = _b[1];
+    var _c = react_1.useState(false), sending = _c[0], setSending = _c[1];
+    var _d = react_1.useState(false), loading = _d[0], setLoading = _d[1];
+    react_1.useEffect(function () {
+        if (isCollaborationEnabled && entity) {
+            var onError = function (e) {
+                console.warn('Collaboration error', e);
+                setCommentsMap(null);
+            };
+            ramda_1.pipe(mdm_sdk_1.getCommentsCount, ramda_1.andThen(ramda_1.map(ramda_1.props(['objectId', 'comments']))), ramda_1.andThen(ramda_1.fromPairs), ramda_1.andThen(setCommentsMap), ramda_1.otherwise(onError))({ uris: objectIds, tenant: tenant, collaborationPath: collaborationPath });
+        }
+        else {
+            setCommentsMap(null);
+        }
+    }, [entity, isCollaborationEnabled, tenant, collaborationPath, objectIds]);
+    var getComment = react_1.useCallback(function (commentId) {
+        setLoading(true);
+        mdm_sdk_1.getComment({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId })
+            .then(setCurrentComment)
+            .catch(function (e) { return console.error('Collaboration error', e); })
+            .finally(function () { return setLoading(false); });
+    }, [collaborationPath, tenant]);
+    var updateComment = function (comment, uri) {
+        setCurrentComment(comment);
+        setCommentsMap(function (prevCommentsMap) {
+            var _a;
+            return __assign(__assign({}, prevCommentsMap), (_a = {}, _a[uri] = __spreadArray(__spreadArray([], (prevCommentsMap[uri] || [])), [{ commentId: comment.commentId, replies: 0, status: 'open' }]), _a));
+        });
+    };
+    var createComment = react_1.useCallback(function (_a) {
+        var content = _a.content, namedUsers = _a.namedUsers, objectType = _a.objectType, uri = _a.uri, relatedObjectUris = _a.relatedObjectUris;
+        setSending(true);
+        var data = {
+            objectId: uri,
+            content: content,
+            relatedObjectUris: relatedObjectUris,
+            objectType: objectType,
+            visibility: 'public',
+            namedUsers: namedUsers,
+            permanentLink: ''
+        };
+        mdm_sdk_1.createComment({ collaborationPath: collaborationPath, tenant: tenant, data: data })
+            .then(function (_a) {
+            var comment = _a[0];
+            return updateComment(comment, uri);
+        })
+            .catch(function (e) { return console.error('Collaboration error', e); })
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant]);
+    var updateReply = react_1.useCallback(function (reply, uri, commentId) {
+        var newStatus = reply.action === 'resolve' ? 'resolved' : 'open';
+        if (newStatus === 'resolved') {
+            setCurrentComment(function (prevCurrentComment) {
+                if (prevCurrentComment) {
+                    return null;
+                }
+            });
+        }
+        else {
+            setCurrentComment(function (prevCurrentComment) {
+                if (prevCurrentComment) {
+                    return __assign(__assign({}, prevCurrentComment), { replies: __spreadArray(__spreadArray([], prevCurrentComment.replies), [reply]) });
+                }
+            });
+        }
+        setCommentsMap(function (prevCommentsMap) {
+            var _a;
+            return (__assign(__assign({}, prevCommentsMap), (_a = {}, _a[uri] = prevCommentsMap[uri].map(function (comment) {
+                if (comment.commentId === commentId) {
+                    return __assign(__assign({}, comment), { status: newStatus, replies: comment.replies + 1 });
+                }
+                return comment;
+            }), _a)));
+        });
+    }, []);
+    var createReply = react_1.useCallback(function (_a) {
+        var content = _a.content, namedUsers = _a.namedUsers, commentId = _a.commentId, action = _a.action, uri = _a.uri;
+        setSending(true);
+        var data = {
+            content: content,
+            action: action,
+            namedUsers: namedUsers
+        };
+        mdm_sdk_1.createReply({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId, data: data })
+            .then(function (_a) {
+            var reply = _a[0];
+            return updateReply(reply, uri, commentId);
+        })
+            .catch(function (e) { return console.error('Collaboration error', e); })
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant, updateReply]);
+    var resolveThread = react_1.useCallback(function (_a) {
+        var commentId = _a.commentId, uri = _a.uri;
+        createReply({ content: '', namedUsers: [], commentId: commentId, action: 'resolve', uri: uri });
+    }, [createReply]);
+    var reOpenThread = react_1.useCallback(function (_a) {
+        var commentId = _a.commentId, uri = _a.uri;
+        createReply({ content: '', namedUsers: [], commentId: commentId, action: 'reopen', uri: uri });
+    }, [createReply]);
+    var clearCurrentComment = react_1.useCallback(function () {
+        setCurrentComment(null);
+    }, []);
+    return {
+        commentsMap: commentsMap,
+        currentComment: currentComment,
+        getComment: getComment,
+        createReply: createReply,
+        createComment: createComment,
+        clearCurrentComment: clearCurrentComment,
+        resolveThread: resolveThread,
+        reOpenThread: reOpenThread,
+        sending: sending,
+        loading: loading
+    };
+};
+exports.useCollaboration = useCollaboration;

package/hooks/useConfigPermissions.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConfigPermissions = void 0;
+var react_redux_1 = require("react-redux");
+var mdm_module_1 = __importDefault(require("@reltio/mdm-module"));
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var react_1 = require("react");
+var useConfigPermissions = function () {
+    var userRoles = react_redux_1.useSelector(mdm_module_1.default.selectors.getUserRoles);
+    return {
+        canCreate: react_1.useCallback(mdm_sdk_1.checkConfigPermission(mdm_sdk_1.ConfigPermissions.CREATE, userRoles), [userRoles]),
+        canRead: react_1.useCallback(mdm_sdk_1.checkConfigPermission(mdm_sdk_1.ConfigPermissions.READ, userRoles), [userRoles]),
+        canUpdate: react_1.useCallback(mdm_sdk_1.checkConfigPermission(mdm_sdk_1.ConfigPermissions.UPDATE, userRoles), [userRoles]),
+        canDelete: react_1.useCallback(mdm_sdk_1.checkConfigPermission(mdm_sdk_1.ConfigPermissions.DELETE, userRoles), [userRoles])
+    };
+};
+exports.useConfigPermissions = useConfigPermissions;

package/hooks/useDidUpdateEffect.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDidUpdateEffect = void 0;
+var react_1 = require("react");
+var useDidUpdateEffect = function (fn, inputs) {
+    var didMountRef = react_1.useRef(false);
+    react_1.useEffect(function () {
+        if (didMountRef.current)
+            fn();
+        else
+            didMountRef.current = true;
+    }, inputs); //eslint-disable-line
+};
+exports.useDidUpdateEffect = useDidUpdateEffect;

package/hooks/usePrevious.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrevious = void 0;
+var react_1 = require("react");
+var usePrevious = function (value) {
+    var valueHolderRef = react_1.useRef();
+    react_1.useEffect(function () {
+        valueHolderRef.current = value;
+    }, [value]);
+    return valueHolderRef.current;
+};
+exports.usePrevious = usePrevious;

package/hooks/useRelationTypeSelector.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRelationTypeSelector = void 0;
+var react_1 = require("react");
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var ramda_1 = require("ramda");
+var useRelationTypeSelector = function (_a) {
+    var reversedContextLabels = _a.reversedContextLabels;
+    var getRelationTypesOptions = react_1.useCallback(function (inRelations, outRelations) {
+        var labelsMap = {};
+        var addLabelInMap = function (label) { return (labelsMap[label] = ramda_1.propOr(0, label, labelsMap) + 1); };
+        var getDirectionalLabel = ramda_1.pipe(mdm_sdk_1.getDirectionalLabelFromObject, ramda_1.tap(addLabelInMap));
+        var byLabel = ramda_1.ascend(ramda_1.prop('label'));
+        var prepareRelation = ramda_1.curry(function (direction, _a) {
+            var uri = _a.uri, label = _a.label, startObject = _a.startObject, endObject = _a.endObject;
+            var dirObject = direction === (reversedContextLabels ? mdm_sdk_1.Directions.OUT : mdm_sdk_1.Directions.IN) ? startObject : endObject;
+            return {
+                label: { directionalLabel: getDirectionalLabel(dirObject), typeLabel: label },
+                value: uri + "," + direction,
+                startObject: startObject,
+                endObject: endObject
+            };
+        });
+        return inRelations
+            .map(prepareRelation(mdm_sdk_1.Directions.IN))
+            .concat(outRelations.map(prepareRelation(mdm_sdk_1.Directions.OUT)))
+            .map(ramda_1.evolve({
+            label: function (_a) {
+                var directionalLabel = _a.directionalLabel, typeLabel = _a.typeLabel;
+                return directionalLabel
+                    ? labelsMap[directionalLabel] > 1
+                        ? directionalLabel + " (" + typeLabel + ")"
+                        : directionalLabel
+                    : typeLabel;
+            }
+        }))
+            .sort(byLabel);
+    }, [reversedContextLabels]);
+    var fromEditorValue = react_1.useCallback(function (inRelationTypes, outRelationTypes) { return function (relation) {
+        var _a = relation.value.split(','), uri = _a[0], direction = _a[1];
+        var type = (direction === mdm_sdk_1.Directions.IN ? inRelationTypes : outRelationTypes).find(ramda_1.propEq('uri', uri));
+        return { type: type, direction: direction };
+    }; }, []);
+    var toEditorValue = react_1.useCallback(function (relation, relationsTypesOptions) {
+        return relationsTypesOptions.find(ramda_1.propEq('value', relation.relationType + "," + relation.direction));
+    }, []);
+    return {
+        getRelationTypesOptions: getRelationTypesOptions,
+        fromEditorValue: fromEditorValue,
+        toEditorValue: toEditorValue
+    };
+};
+exports.useRelationTypeSelector = useRelationTypeSelector;

package/hooks/useRelationsLoader.js

@@ -0,0 +1,111 @@
+"use strict";
+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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRelationsLoader = void 0;
+var react_1 = require("react");
+var react_redux_1 = require("react-redux");
+var ramda_1 = require("ramda");
+var mdm_module_1 = __importStar(require("@reltio/mdm-module"));
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var useSafePromise_1 = require("./useSafePromise");
+var usePrevious_1 = require("./usePrevious");
+var useRelationsLoader = function (_a) {
+    var sorting = _a.sorting, filter = _a.filter, page = _a.page, rowsPerPage = _a.rowsPerPage, config = _a.config, entity = _a.entity, relationActivityFilter = _a.relationActivityFilter, mode = _a.mode;
+    var _b = react_1.useState(false), isLoading = _b[0], setIsLoading = _b[1];
+    var dispatch = react_redux_1.useDispatch();
+    var tenant = react_redux_1.useSelector(mdm_module_1.default.selectors.getTenant);
+    var dtssPath = react_redux_1.useSelector(mdm_module_1.default.selectors.getDtssPath);
+    var _c = react_redux_1.useSelector(mdm_module_1.default.selectors.getGlobalSearchRequestOptions) || {}, activityFilter = _c.activityFilter, globalFilter = _c.globalFilter;
+    var safePromise = useSafePromise_1.useSafePromise();
+    var loadRelations = react_1.useCallback(function () {
+        if (entity === null || entity === void 0 ? void 0 : entity.uri) {
+            var requestConfig_1 = __assign(__assign({}, config.content), { sortBy: sorting.field, order: sorting.order, returnDates: true, returnObjects: true, activeness: {
+                    relation: relationActivityFilter || mdm_sdk_1.ActivityFilter.ALL,
+                    entity: activityFilter
+                }, max: rowsPerPage, offset: page * rowsPerPage, filter: mdm_sdk_1.addGlobalFilterToQuery(globalFilter, filter) || undefined });
+            var request = ramda_1.cond([
+                [ramda_1.pipe(ramda_1.prop('uri'), mdm_sdk_1.isTempUri), function () { return Promise.resolve([{ total: 0 }]); }],
+                [
+                    mdm_sdk_1.isDataTenantEntity,
+                    function (entity) {
+                        return mdm_sdk_1.getRelationsForDataTenantEntity({
+                            entityUri: entity.uri,
+                            configs: [requestConfig_1],
+                            customerTenant: tenant,
+                            dataTenant: entity.dataTenant,
+                            dtssPath: dtssPath
+                        });
+                    }
+                ],
+                [ramda_1.T, function (entity) { return mdm_sdk_1.getRelationsForEntity(entity.uri, [requestConfig_1]); }]
+            ]);
+            setIsLoading(true);
+            safePromise(request(entity))
+                .then(function (_a) {
+                var _b = _a[0], connections = _b.connections, total = _b.total;
+                dispatch(mdm_module_1.profile.relations.actions.relationsLoaded({ id: config.id, connections: connections, total: total }));
+            })
+                .finally(function () {
+                setIsLoading(false);
+            });
+        }
+    }, [
+        activityFilter,
+        config,
+        dispatch,
+        dtssPath,
+        entity,
+        filter,
+        globalFilter,
+        page,
+        relationActivityFilter,
+        rowsPerPage,
+        safePromise,
+        sorting,
+        tenant
+    ]);
+    var isRequestSentRef = react_1.useRef(false);
+    isRequestSentRef.current = false;
+    react_1.useEffect(function () {
+        isRequestSentRef.current = true;
+        loadRelations();
+    }, [loadRelations]);
+    var prevMode = usePrevious_1.usePrevious(mode);
+    react_1.useEffect(function () {
+        if (mode === mdm_sdk_1.Mode.Viewing && !isRequestSentRef.current && prevMode !== mode) {
+            isRequestSentRef.current = true;
+            loadRelations();
+        }
+    }, [loadRelations, mode, prevMode]);
+    return isLoading;
+};
+exports.useRelationsLoader = useRelationsLoader;

package/hooks/useRunOnceAfterValueInitialization.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRunOnceAfterValueInitialization = void 0;
+var react_1 = require("react");
+var useRunOnceAfterValueInitialization = function (cb, value) {
+    var isValueInited = react_1.useRef(false);
+    react_1.useEffect(function () {
+        if (value && !isValueInited.current) {
+            isValueInited.current = true;
+            cb();
+        }
+    }, [cb, value]);
+};
+exports.useRunOnceAfterValueInitialization = useRunOnceAfterValueInitialization;

package/hooks/useSafePromise.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSafePromise = void 0;
+var react_1 = require("react");
+var core_1 = require("../core");
+var PromiseStub = new Promise(function () { });
+var useSafePromise = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.cancelPrevious, cancelPrevious = _c === void 0 ? true : _c, _d = _b.cancelOnUnmount, cancelOnUnmount = _d === void 0 ? true : _d;
+    var cancelRef = react_1.useRef(core_1.noop);
+    var cancelPromise = function () { return cancelRef.current(); };
+    react_1.useEffect(function () { return function () {
+        if (cancelOnUnmount) {
+            cancelPromise();
+        }
+    }; }, [] //eslint-disable-line
+    );
+    return react_1.useCallback(function (promise) {
+        if (cancelPrevious) {
+            cancelPromise();
+        }
+        return new Promise(function (resolve, reject) {
+            cancelRef.current = function () { return reject('canceled'); };
+            promise.then(resolve, reject);
+        }).catch(function (error) {
+            if (error === 'canceled') {
+                return PromiseStub;
+            }
+            else {
+                throw error;
+            }
+        });
+    }, []); //eslint-disable-line
+};
+exports.useSafePromise = useSafePromise;

package/hooks/useSavedState.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSavedState = void 0;
+var react_1 = require("react");
+var useSavedState = function (getSavedState) {
+    var _a = react_1.useState(false), isLoaded = _a[0], setIsLoaded = _a[1];
+    var _b = react_1.useState({}), savedState = _b[0], setSavedState = _b[1];
+    react_1.useEffect(function () {
+        getSavedState()
+            .then(function (savedState) {
+            setSavedState(savedState || {});
+        })
+            .then(function (_) { return setIsLoaded(true); })
+            .catch(function (_) { return setIsLoaded(true); });
+    }, []); // eslint-disable-line
+    return { isLoaded: isLoaded, savedState: savedState };
+};
+exports.useSavedState = useSavedState;

package/hooks/useUsers.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUsers = void 0;
+var react_1 = require("react");
+var react_redux_1 = require("react-redux");
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var mdm_module_1 = __importDefault(require("@reltio/mdm-module"));
+var useUsers = function () {
+    var _a = react_1.useState([]), users = _a[0], setUsers = _a[1];
+    var tenant = react_redux_1.useSelector(mdm_module_1.default.selectors.getTenant);
+    var uiPath = react_redux_1.useSelector(mdm_module_1.default.selectors.getUIPath);
+    var onError = function (e) {
+        console.warn('Users error', e);
+        setUsers([]);
+    };
+    react_1.useEffect(function () {
+        mdm_sdk_1.getAllUsersForTenant(tenant, uiPath)
+            .then(function (_a) {
+            var array = _a.array;
+            return setUsers(array);
+        })
+            .catch(onError);
+    }, [tenant, uiPath]);
+    return users;
+};
+exports.useUsers = useUsers;