@reltio/components 1.4.1876 → 1.4.1877

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

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

package/esm/hooks/useActions/index.js

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

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

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

package/esm/hooks/useAsyncMount/index.js

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

package/esm/hooks/useAsyncMount/useAsyncMount.js

@@ -0,0 +1,23 @@
+import { useContext, useEffect, useState, useRef } from 'react';
+import { AsyncMountContext } from '../../contexts/AsyncMountContext';
+var queueSize = 0;
+export var useAsyncMount = function () {
+    var isFirstRunRef = useRef(true);
+    var _a = useContext(AsyncMountContext), enabled = _a.enabled, _b = _a.queueSizeThreshold, queueSizeThreshold = _b === void 0 ? 0 : _b;
+    var _c = useState(!enabled || (enabled && queueSize < queueSizeThreshold)), shouldMount = _c[0], setShouldMount = _c[1];
+    if (isFirstRunRef.current) {
+        queueSize++;
+    }
+    var timerRef = useRef();
+    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;
+};

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

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

package/esm/hooks/useAttributeState/index.js

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

package/esm/hooks/useAttributeState/useAttributeState.js

@@ -0,0 +1,39 @@
+import { debounce } from '@reltio/mdm-sdk';
+import { useCallback, useEffect, useState } from 'react';
+var AttributeStates;
+(function (AttributeStates) {
+    AttributeStates["Reading"] = "Reading";
+    AttributeStates["Hovered"] = "Hovered";
+    AttributeStates["Editing"] = "Editing";
+})(AttributeStates || (AttributeStates = {}));
+var HIDE_INTERVAL = 50;
+export var useAttributeState = function () {
+    var _a = useState(null), attributeState = _a[0], setAttributeState = _a[1];
+    var isReadingMode = attributeState === AttributeStates.Reading;
+    var isEditingMode = attributeState === AttributeStates.Editing;
+    var isHovered = attributeState === AttributeStates.Hovered;
+    useEffect(function () {
+        setAttributeState(AttributeStates.Reading);
+    }, []);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    var setAttributeStateDebounced = useCallback(debounce(setAttributeState, HIDE_INTERVAL), []);
+    var onMouseEnter = useCallback(function () {
+        if (!isEditingMode)
+            setAttributeStateDebounced(AttributeStates.Hovered);
+    }, [setAttributeStateDebounced, isEditingMode]);
+    var onMouseLeave = useCallback(function () {
+        if (!isEditingMode)
+            setAttributeStateDebounced(AttributeStates.Reading);
+    }, [setAttributeStateDebounced, isEditingMode]);
+    var setReadingMode = useCallback(function () { return setAttributeState(AttributeStates.Reading); }, [setAttributeState]);
+    var setEditingMode = useCallback(function () { return setAttributeState(AttributeStates.Editing); }, [setAttributeState]);
+    return {
+        setReadingMode: setReadingMode,
+        setEditingMode: setEditingMode,
+        onMouseLeave: onMouseLeave,
+        onMouseEnter: onMouseEnter,
+        isReadingMode: isReadingMode,
+        isEditingMode: isEditingMode,
+        isHovered: isHovered
+    };
+};

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

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

package/esm/hooks/useAutoFocus/index.js

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

package/esm/hooks/useBasicTableCellRenderer/useBasicTableCellRenderer.test.js

@@ -21,9 +21,9 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import React from 'react';
+import { render, screen } from '@testing-library/react';
 import { useBasicTableCellRenderer } from './useBasicTableCellRenderer';
 import { CellRenderer } from './CellRenderer';
-import { render, screen } from '@testing-library/react';
 // eslint-disable-next-line react/prop-types
 var TestComponent = function (_a) {
     var columnId = _a.columnId, columnsData = _a.columnsData, rowsData = _a.rowsData, otherProps = __rest(_a, ["columnId", "columnsData", "rowsData"]);

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

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

package/esm/hooks/useChangedAttributes/index.js

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

package/esm/hooks/useChangedAttributes/useChangedAttributes.js

@@ -0,0 +1,33 @@
+import { useMemo, useRef } from 'react';
+import { attributeUriToSearchUri, getOvAttributeValuesByPathWithUri } from '@reltio/mdm-sdk';
+import { flatten, isNil, join, pipe, pluck } from 'ramda';
+var getValues = function (controlAttribute, attributes) {
+    if (attributes === void 0) { attributes = {}; }
+    var searchUri = attributeUriToSearchUri(controlAttribute);
+    var attrPath = searchUri.replace('attributes.', '').split('.');
+    return flatten(getOvAttributeValuesByPathWithUri(attrPath, attributes));
+};
+var getValuesHash = pipe(pluck('value'), join('-'));
+export var useChangedAttributes = function (attributes, controlAttributes) {
+    var previousAttributesValues = useRef();
+    var attributeValues = useMemo(function () {
+        return controlAttributes.reduce(function (values, controlAttribute) {
+            values[controlAttribute] = pipe(getValues, getValuesHash)(controlAttribute, attributes);
+            return values;
+        }, {}) || [];
+    }, [controlAttributes, attributes]);
+    var changedAttributes = useMemo(function () {
+        var attributeUris = Object.keys(attributeValues);
+        return previousAttributesValues.current
+            ? attributeUris.reduce(function (changedAttributes, attributeUri) {
+                var attributeValue = attributeValues[attributeUri];
+                var previousAttributeValue = previousAttributesValues.current[attributeUri];
+                return isNil(previousAttributeValue) || previousAttributeValue !== attributeValue
+                    ? changedAttributes.concat(attributeUri)
+                    : changedAttributes;
+            }, []) || []
+            : attributeUris;
+    }, [attributeValues]);
+    previousAttributesValues.current = attributeValues;
+    return changedAttributes;
+};

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

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

package/esm/hooks/useChartTooltipState/index.js

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

package/esm/hooks/useChartTooltipState/useChartTooltipState.d.ts

@@ -0,0 +1,7 @@
+import { TooltipProps } from 'recharts';
+import { ChartData } from '../../types/charts';
+export declare const useChartTooltipState: () => {
+    tooltipState: TooltipProps<number, string>;
+    showTooltip: (data: ChartData, coordinate: TooltipProps<number, string>['coordinate']) => void;
+    hideTooltip: () => void;
+};

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

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

package/esm/hooks/useClickableChartStyle/index.js

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

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

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

package/esm/hooks/useCollaboration/index.js

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

package/esm/hooks/useCollaboration/useCollaboration.js

@@ -0,0 +1,296 @@
+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 { useCallback, useEffect, useState } from 'react';
+import { andThen, fromPairs, map, otherwise, pipe, props, uniqBy, prop, propEq, when, always, assocPath, dissocPath, path, pathOr, mergeRight } from 'ramda';
+import { createComment as createCommentRequest, createReply as createReplyRequest, getComment as getCommentRequest, getCommentsCount as getCommentsCountRequest, updateComment as updateCommentRequest, updateReply as updateReplyRequest, deleteComment as deleteCommentRequest, deleteReply as deleteReplyRequest, getComments as getCommentsRequest, isTempUri } from '@reltio/mdm-sdk';
+import { useMdmCollaborationPath, useMdmEntity, useMdmIsCollaborationEnabled, useMdmTenant } from '../../contexts/MdmModuleContext';
+var filterReplies = function (replyId, replies) { return replies.filter(function (reply) { return reply.replyId !== replyId; }); };
+var getUpdatedReplies = function (comment, reply) {
+    var changedReplyIndex = comment.replies.findIndex(function (_a) {
+        var replyId = _a.replyId;
+        return replyId === reply.replyId;
+    });
+    var newReplies = __spreadArray([], comment.replies, true);
+    newReplies[changedReplyIndex] = reply;
+    return newReplies;
+};
+var defaultObjectIds = [];
+var catchErrorInRequest = function (e) { return console.warn('Collaboration error', e); };
+export var useCollaboration = function (_a) {
+    var _b = _a.objectIds, objectIds = _b === void 0 ? defaultObjectIds : _b, objectTypes = _a.objectTypes, _c = _a.enabled, enabled = _c === void 0 ? true : _c;
+    var entity = useMdmEntity();
+    var tenant = useMdmTenant();
+    var collaborationPath = useMdmCollaborationPath();
+    var isCollaborationEnabled = useMdmIsCollaborationEnabled() && enabled;
+    var _d = useState(null), pageToken = _d[0], setPageToken = _d[1];
+    var _e = useState([]), comments = _e[0], setComments = _e[1];
+    var _f = useState(null), commentsMap = _f[0], setCommentsMap = _f[1];
+    var _g = useState(null), currentComment = _g[0], setCurrentComment = _g[1];
+    var _h = useState(false), sending = _h[0], setSending = _h[1];
+    var _j = useState(false), loading = _j[0], setLoading = _j[1];
+    var _k = useState({}), collaborationStateMap = _k[0], setCollaborationStateMap = _k[1];
+    var addCommentsToCommentsMap = useCallback(function (commentsMap) {
+        setCommentsMap(function (currentCommentsMap) { return (__assign(__assign({}, currentCommentsMap), commentsMap)); });
+    }, []);
+    var entityUri = entity === null || entity === void 0 ? void 0 : entity.uri;
+    var getCommentsCount = useCallback(function (objectIds, shouldResetCommentsMap) {
+        if (shouldResetCommentsMap === void 0) { shouldResetCommentsMap = false; }
+        if (isCollaborationEnabled && entityUri && !isTempUri(entityUri)) {
+            var onError = function (e) {
+                console.warn('Collaboration error', e);
+                setCommentsMap(null);
+            };
+            pipe(getCommentsCountRequest, andThen(map(props(['objectId', 'comments']))), andThen(fromPairs), andThen(shouldResetCommentsMap ? setCommentsMap : addCommentsToCommentsMap), otherwise(onError))({ uris: objectIds, tenant: tenant, collaborationPath: collaborationPath });
+        }
+        else {
+            setCommentsMap(null);
+        }
+    }, [addCommentsToCommentsMap, collaborationPath, entityUri, isCollaborationEnabled, tenant]);
+    useEffect(function () {
+        getCommentsCount(objectIds, true);
+    }, [objectIds, getCommentsCount]);
+    var getComments = useCallback(function (relatedObjectUri, pageToken) {
+        getCommentsRequest({ collaborationPath: collaborationPath, tenant: tenant, relatedObjectUri: relatedObjectUri, pageToken: pageToken })
+            .then(function (_a) {
+            var items = _a.items, nextPageToken = _a.nextPageToken;
+            setComments(function (prevComments) {
+                if (!pageToken) {
+                    return items;
+                }
+                return uniqBy(prop('commentId'), __spreadArray(__spreadArray([], prevComments, true), items, true));
+            });
+            setPageToken(nextPageToken);
+        })
+            .catch(catchErrorInRequest);
+    }, [collaborationPath, tenant]);
+    var getComment = useCallback(function (commentId) {
+        setLoading(true);
+        getCommentRequest({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId })
+            .then(setCurrentComment)
+            .catch(catchErrorInRequest)
+            .finally(function () { return setLoading(false); });
+    }, [collaborationPath, tenant]);
+    var addCommentToState = function (comment, uri) {
+        setCurrentComment(comment);
+        setCommentsMap(function (prevCommentsMap) {
+            var _a;
+            return __assign(__assign({}, prevCommentsMap), (_a = {}, _a[uri] = __spreadArray(__spreadArray([], (prevCommentsMap[uri] || []), true), [{ commentId: comment.commentId, replies: 0, status: 'open' }], false), _a));
+        });
+        setComments(function (prevComments) { return __spreadArray([comment], prevComments, true); });
+    };
+    var updateCommentInState = function (comment) {
+        setCurrentComment(comment);
+        setComments(map(when(propEq('commentId', comment.commentId), always(comment))));
+    };
+    var deleteCommentFromState = function (commentId, uri) {
+        setCurrentComment(null);
+        setCommentsMap(function (prevCommentsMap) {
+            var _a;
+            var comments = prevCommentsMap[uri] || [];
+            return __assign(__assign({}, prevCommentsMap), (_a = {}, _a[uri] = comments.filter(function (c) { return c.commentId !== commentId; }), _a));
+        });
+        setComments(function (prevComments) {
+            return prevComments.filter(function (comment) { return comment.commentId !== commentId; });
+        });
+    };
+    var createComment = 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: "".concat(window.location.href, "&commentId=").concat(encodeURIComponent('{commentId}'))
+        };
+        return createCommentRequest({ collaborationPath: collaborationPath, tenant: tenant, data: data })
+            .then(function (_a) {
+            var comment = _a[0];
+            return addCommentToState(comment, uri);
+        })
+            .catch(catchErrorInRequest)
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant]);
+    var editComment = useCallback(function (_a) {
+        var content = _a.content, namedUsers = _a.namedUsers, objectType = _a.objectType, uri = _a.uri, relatedObjectUris = _a.relatedObjectUris, commentId = _a.commentId, replies = _a.replies;
+        setSending(true);
+        var data = {
+            objectId: uri,
+            content: content,
+            relatedObjectUris: relatedObjectUris,
+            objectType: objectType,
+            visibility: 'public',
+            namedUsers: namedUsers,
+            commentId: commentId,
+            replies: replies
+        };
+        return updateCommentRequest({ collaborationPath: collaborationPath, tenant: tenant, data: data })
+            .then(function (comment) { return updateCommentInState(__assign(__assign({}, comment), { replies: replies })); })
+            .catch(catchErrorInRequest)
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant]);
+    var deleteComment = useCallback(function (_a) {
+        var uri = _a.uri, commentId = _a.commentId;
+        setSending(true);
+        deleteCommentRequest({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId })
+            .then(function () { return deleteCommentFromState(commentId, uri); })
+            .catch(catchErrorInRequest)
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant]);
+    var updateReplyInState = useCallback(function (reply, uri, commentId, isDeleteReply) {
+        var newStatus = reply.action === 'resolve' ? 'resolved' : 'open';
+        var replyId = reply.replyId;
+        if (newStatus === 'resolved') {
+            setCurrentComment(function (prevCurrentComment) {
+                if (prevCurrentComment) {
+                    return null;
+                }
+            });
+        }
+        else {
+            setCurrentComment(function (prevCurrentComment) {
+                if (prevCurrentComment) {
+                    return __assign(__assign({}, prevCurrentComment), { replies: isDeleteReply
+                            ? filterReplies(replyId, prevCurrentComment.replies)
+                            : __spreadArray(__spreadArray([], prevCurrentComment.replies, true), [reply], false) });
+                }
+            });
+        }
+        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: isDeleteReply ? comment.replies - 1 : comment.replies + 1 });
+                }
+                return comment;
+            }), _a)));
+        });
+        setComments(function (prevComments) {
+            return prevComments.map(function (comment) {
+                if (comment.commentId === commentId) {
+                    return __assign(__assign({}, comment), { status: newStatus, replies: isDeleteReply
+                            ? filterReplies(reply.replyId, comment.replies)
+                            : __spreadArray(__spreadArray([], comment.replies, true), [reply], false) });
+                }
+                return comment;
+            });
+        });
+    }, []);
+    var deleteReply = useCallback(function (_a) {
+        var uri = _a.uri, commentId = _a.commentId, reply = _a.reply;
+        setSending(true);
+        deleteReplyRequest({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId, replyId: reply.replyId })
+            .then(function () { return updateReplyInState(reply, uri, commentId, true); })
+            .catch(catchErrorInRequest)
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, updateReplyInState, tenant]);
+    var editReplyInState = useCallback(function (reply, commentId) {
+        setCurrentComment(function (prevCurrentComment) {
+            if (prevCurrentComment) {
+                return __assign(__assign({}, prevCurrentComment), { replies: getUpdatedReplies(prevCurrentComment, reply) });
+            }
+        });
+        setComments(function (prevComments) {
+            return prevComments.map(function (comment) {
+                if (comment.commentId === commentId) {
+                    return __assign(__assign({}, comment), { replies: getUpdatedReplies(comment, reply) });
+                }
+                return comment;
+            });
+        });
+    }, []);
+    var editReply = useCallback(function (_a) {
+        var content = _a.content, namedUsers = _a.namedUsers, commentId = _a.commentId, replyId = _a.replyId;
+        setSending(true);
+        var data = {
+            content: content,
+            namedUsers: namedUsers
+        };
+        return updateReplyRequest({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId, replyId: replyId, data: data })
+            .then(function (reply) { return editReplyInState(reply, commentId); })
+            .catch(catchErrorInRequest)
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant, editReplyInState]);
+    var createReply = 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
+        };
+        return createReplyRequest({ collaborationPath: collaborationPath, tenant: tenant, commentId: commentId, data: data })
+            .then(function (_a) {
+            var reply = _a[0];
+            return updateReplyInState(reply, uri, commentId);
+        })
+            .catch(catchErrorInRequest)
+            .finally(function () { return setSending(false); });
+    }, [collaborationPath, tenant, updateReplyInState]);
+    var resolveThread = useCallback(function (_a) {
+        var commentId = _a.commentId, uri = _a.uri;
+        createReply({ content: '', namedUsers: [], commentId: commentId, action: 'resolve', uri: uri });
+    }, [createReply]);
+    var reOpenThread = useCallback(function (_a) {
+        var commentId = _a.commentId, uri = _a.uri;
+        createReply({ content: '', namedUsers: [], commentId: commentId, action: 'reopen', uri: uri });
+    }, [createReply]);
+    var clearCurrentComment = useCallback(function () {
+        setCurrentComment(null);
+    }, []);
+    var getCommentState = function (uri, commentUri) { return pathOr({}, [uri, commentUri], collaborationStateMap); };
+    var clearCommentState = function (uri, commentUri) {
+        return setCollaborationStateMap(dissocPath([uri, commentUri]));
+    };
+    var updateCommentState = function (uri, commentUri, newState) {
+        setCollaborationStateMap(function (prevCollaborationStateMap) {
+            var pathToCommentState = [uri, commentUri];
+            var prevCommentState = path(pathToCommentState, prevCollaborationStateMap);
+            return assocPath(pathToCommentState, mergeRight(prevCommentState, newState), prevCollaborationStateMap);
+        });
+    };
+    return {
+        clearCurrentComment: clearCurrentComment,
+        comments: comments,
+        commentsMap: commentsMap,
+        getCommentState: getCommentState,
+        updateCommentState: updateCommentState,
+        clearCommentState: clearCommentState,
+        createComment: createComment,
+        createReply: createReply,
+        currentComment: currentComment,
+        deleteComment: deleteComment,
+        editComment: editComment,
+        getComment: getComment,
+        getComments: getComments,
+        getCommentsCount: getCommentsCount,
+        loading: loading,
+        objectTypes: objectTypes,
+        pageToken: pageToken,
+        reOpenThread: reOpenThread,
+        resolveThread: resolveThread,
+        sending: sending,
+        deleteReply: deleteReply,
+        editReply: editReply
+    };
+};

package/esm/hooks/useCollaboration/useCollaboration.specs.d.ts

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