@reltio/components 1.4.2243 → 1.4.2244

package/features/workflow/ChangeRequestEditor/hooks/useChangeRequestEditor.d.ts

@@ -1,5 +1,5 @@
-import { PrimitiveValue, SimpleAttributeValue } from '@reltio/mdm-sdk';
-import { Diff } from '../../types';
+import { type PrimitiveValue, type SimpleAttributeValue } from '@reltio/mdm-sdk';
+import type { Diff, LineDataValue } from '../../types';
 type Props = {
     change: Diff;
 };
@@ -7,11 +7,12 @@ export declare const useChangeRequestEditor: ({ change }: Props) => {
     handleChange: (newValue: SimpleAttributeValue | string[] | PrimitiveValue) => void;
     handleReject: () => void;
     handleRevert: () => void;
+    handleImageUpload: (value: LineDataValue) => void;
     lineData: import("../../types").LineData;
     isLineRejected: boolean;
     isParentLineRejected: boolean;
     isUpdated: boolean;
     hasChangeId: boolean;
-    isSubAttributeOfDeletedAttribute: any;
+    isSubAttributeOfDeletedAttribute: boolean;
 };
 export {};

package/features/workflow/ChangeRequestEditor/hooks/useChangeRequestEditor.js

@@ -1,8 +1,10 @@
 import { useCallback } from 'react';
+import { isEmpty } from 'ramda';
 import { useContextSelector } from '@fluentui/react-context-selector';
 import { DCROperationTypes } from '@reltio/mdm-sdk';
 import { ChangeRequestEditorContext } from '../../contexts/ChangeRequestEditorContext';
 import { extractLineIds } from '../../helpers/merge';
+import { isSimpleAttributeValue } from '../helpers/helpers';
 var emptyLineIds = [];
 export var useChangeRequestEditor = function (_a) {
     var change = _a.change;
@@ -22,7 +24,7 @@ export var useChangeRequestEditor = function (_a) {
         lineIds.length > 0 &&
         lineIds[0].includes('/value/');
     var handleChange = useCallback(function (newValue) {
-        updateChange(lineIds, typeof newValue === 'object' && 'value' in newValue ? newValue : { value: newValue });
+        updateChange(lineIds, isSimpleAttributeValue(newValue) ? newValue : { value: newValue });
     }, [lineIds, updateChange]);
     var handleReject = useCallback(function () {
         rejectChange(lineIds);
@@ -30,10 +32,16 @@ export var useChangeRequestEditor = function (_a) {
     var handleRevert = useCallback(function () {
         revertChangeUpdateOrReject(lineIds);
     }, [revertChangeUpdateOrReject, lineIds]);
+    var handleImageUpload = useCallback(function (value) {
+        if (isEmpty(lineIds))
+            return;
+        updateChange(lineIds, value);
+    }, [lineIds, updateChange]);
     return {
         handleChange: handleChange,
         handleReject: handleReject,
         handleRevert: handleRevert,
+        handleImageUpload: handleImageUpload,
         lineData: lineData,
         isLineRejected: isLineRejected,
         isParentLineRejected: isParentLineRejected,

package/features/workflow/ChangeRequestEditor/hooks/useNewAttributesEditor.d.ts

@@ -0,0 +1,18 @@
+import type { PrimitiveValue, SimpleAttributeValue } from '@reltio/mdm-sdk';
+import type { Diff, LineDataValue } from '../../types';
+import type { EntityOption } from '../../../../EntitySelector/types';
+type Props = {
+    change: Diff;
+};
+export declare const useNewAttributesEditor: ({ change }: Props) => {
+    lineData: import("../../types").LineData;
+    addedId: string;
+    selectedEntity: import("@reltio/mdm-sdk").ConnectionEntity;
+    isRejected: boolean;
+    hasAddedParent: boolean;
+    handleDelete: () => void;
+    handleChange: (newValue: SimpleAttributeValue | string[] | PrimitiveValue) => void;
+    handleEntityChange: (entity: EntityOption) => void;
+    handleImageUpload: (value: LineDataValue) => void;
+};
+export {};

package/features/workflow/ChangeRequestEditor/hooks/useNewAttributesEditor.js

@@ -0,0 +1,61 @@
+import { useCallback } from 'react';
+import { useContextSelector } from '@fluentui/react-context-selector';
+import { ChangeRequestEditorContext } from '../../contexts/ChangeRequestEditorContext';
+import { extractLineIds } from '../../helpers/merge';
+import { isSimpleAttributeValue } from '../helpers/helpers';
+import { getAddedId, hasParentAddedAttribute } from '../helpers/addedAttributes';
+import { AddedAttributesContext } from '../../contexts/AddedAttributesContext';
+var emptyLineIds = [];
+export var useNewAttributesEditor = function (_a) {
+    var change = _a.change;
+    var addedId = getAddedId(change);
+    var hasAddedParent = hasParentAddedAttribute(addedId);
+    var lineIds = change.lineIds || extractLineIds(change === null || change === void 0 ? void 0 : change.newValue) || emptyLineIds;
+    var lineData = useContextSelector(ChangeRequestEditorContext, function (context) { return context.getLineData(lineIds[0]); });
+    var updateChange = useContextSelector(ChangeRequestEditorContext, function (context) { return context.updateChange; });
+    var isLineRejected = useContextSelector(ChangeRequestEditorContext, function (context) {
+        return context.getIsLineRejected(lineIds[0]);
+    });
+    var isParentLineRejected = useContextSelector(ChangeRequestEditorContext, function (context) {
+        return context.getIsParentLineRejected(lineIds[0]);
+    });
+    var isRejected = isLineRejected || isParentLineRejected;
+    var deleteLineData = useContextSelector(ChangeRequestEditorContext, function (ctx) { return ctx.deleteLineData; });
+    var removeAddedAttribute = useContextSelector(AddedAttributesContext, function (ctx) { return ctx.removeAddedAttribute; });
+    var updateAddedAttributeRefEntity = useContextSelector(AddedAttributesContext, function (ctx) { return ctx.updateAddedAttributeRefEntity; });
+    var selectedEntity = useContextSelector(AddedAttributesContext, function (ctx) { var _a; return addedId ? (_a = ctx.getAddedAttributes().find(function (a) { return a.id === addedId; })) === null || _a === void 0 ? void 0 : _a.refEntity : undefined; });
+    var handleChange = useCallback(function (newValue) {
+        updateChange(lineIds, isSimpleAttributeValue(newValue) ? newValue : { value: newValue });
+    }, [lineIds, updateChange]);
+    var handleDelete = useCallback(function () {
+        if (!addedId)
+            return;
+        removeAddedAttribute(addedId);
+        deleteLineData(lineIds);
+    }, [addedId, deleteLineData, lineIds, removeAddedAttribute]);
+    var handleEntityChange = useCallback(function (entity) {
+        if (!addedId)
+            return;
+        updateAddedAttributeRefEntity(addedId, {
+            entityUri: entity.uri,
+            entityType: entity.type,
+            entityLabel: entity.label
+        });
+    }, [addedId, updateAddedAttributeRefEntity]);
+    var handleImageUpload = useCallback(function (value) {
+        if (lineIds.length === 0)
+            return;
+        updateChange(lineIds, value);
+    }, [lineIds, updateChange]);
+    return {
+        lineData: lineData,
+        addedId: addedId,
+        selectedEntity: selectedEntity,
+        isRejected: isRejected,
+        hasAddedParent: hasAddedParent,
+        handleDelete: handleDelete,
+        handleChange: handleChange,
+        handleEntityChange: handleEntityChange,
+        handleImageUpload: handleImageUpload
+    };
+};

package/features/workflow/WorkflowTaskCard/components/DataChangeRequestTaskCard/DataChangeRequestTaskCard.js

@@ -10,7 +10,9 @@ import { useChangeRequest } from '../../../hooks/useChangeRequest';
 import { getDCRUri } from '../../../helpers/common';
 import { ReviewDCRDialog } from '../../../ReviewDCRDialog';
 import { ReviewDCRButton } from '../../../ReviewDCRButton';
+import { AddedAttributesProvider } from '../../../contexts/AddedAttributesContext';
 import { ChangeRequestEditorProvider } from '../../../contexts/ChangeRequestEditorContext';
+import { ScrollToAddedAttributeProvider } from '../../../contexts/ScrollToAddedAttributeContext';
 import { WorkflowTasksContext } from '../../../../../contexts/WorkflowTasksContext';
 import { ScrollToElementProvider } from '../../../../../contexts/ScrollToElementContext';
 export var DataChangeRequestTaskCard = function (_a) {
@@ -38,7 +40,9 @@ export var DataChangeRequestTaskCard = function (_a) {
         React.createElement(GenericWorkflowTaskCard, { task: task, Icon: DcrTaskIcon, customActionsSlot: customActionsSlot }, dcr &&
             groupedObjects.map(function (object, index) { return (React.createElement(LineDecorator, { key: index, last: index === groupedObjects.length - 1, divider: true },
                 React.createElement(AttributesChanges, { entityInfo: object.entity, relationsInfo: object.relations, changes: dcr.changes, objectsInfo: dcr.objectsInfo, dcrUri: dcrUri }))); })),
-        showReviewDialog && (React.createElement(ChangeRequestEditorProvider, null,
-            React.createElement(ScrollToElementProvider, null,
-                React.createElement(ReviewDCRDialog, { open: isReviewDCRDialogOpen, onClose: handleCloseReviewDCRDialog, dcr: dcr, groupedObjects: groupedObjects, task: task }))))));
+        showReviewDialog && (React.createElement(AddedAttributesProvider, null,
+            React.createElement(ChangeRequestEditorProvider, null,
+                React.createElement(ScrollToElementProvider, null,
+                    React.createElement(ScrollToAddedAttributeProvider, null,
+                        React.createElement(ReviewDCRDialog, { open: isReviewDCRDialogOpen, onClose: handleCloseReviewDCRDialog, dcr: dcr, groupedObjects: groupedObjects, task: task }))))))));
 };

package/features/workflow/contexts/AddedAttributesContext/index.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { type AttributeType, type ConnectionEntity } from '@reltio/mdm-sdk';
+export declare const ADDED_ID_SEPARATOR = "|";
+export declare const ADDED_CHANGE_ID_PREFIX = "added|";
+export type ChangeOverrides = {
+    attributePath?: string;
+    refAttributeType?: string;
+    refObjectURI?: string;
+};
+export type AddedAttributeInitialValue = {
+    value?: unknown;
+    lookupCode?: string;
+};
+export type AddedAttribute = {
+    attributeType: AttributeType;
+    id: string;
+    objectUri?: string;
+    parentLineId?: string;
+    parentId?: string;
+    changeOverrides?: ChangeOverrides;
+    initialValue?: AddedAttributeInitialValue;
+    refEntity?: ConnectionEntity;
+};
+export type AddedAttributesContextType = {
+    getAddedAttributes: () => AddedAttribute[];
+    addAddedAttributes: ({ attributeTypes, objectUri, parentLineId, parentId, changeOverrides }: {
+        attributeTypes: AttributeType[];
+        objectUri?: string;
+        parentLineId?: string;
+        parentId?: string;
+        changeOverrides?: ChangeOverrides;
+    }) => string[];
+    removeAddedAttribute: (id: string) => void;
+    updateAddedAttributeRefEntity: (id: string, refEntity: ConnectionEntity) => void;
+};
+export declare const AddedAttributesContext: import("@fluentui/react-context-selector").Context<AddedAttributesContextType>;
+export declare const AddedAttributesProvider: ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;

package/features/workflow/contexts/AddedAttributesContext/index.js

@@ -0,0 +1,125 @@
+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 React, { useCallback, useMemo, useState } from 'react';
+import { createContext } from '@fluentui/react-context-selector';
+import { nanoid } from 'nanoid';
+import { createNewAttributeValue, isComplexAttribute, isImage } from '@reltio/mdm-sdk';
+import { useMdmMetadata } from '../../../../contexts/MdmModuleContext';
+import { getAvailableSubAttributesForNestedOrReference } from '../../helpers/moreAttributesScope';
+export var ADDED_ID_SEPARATOR = '|';
+export var ADDED_CHANGE_ID_PREFIX = "added".concat(ADDED_ID_SEPARATOR);
+export var AddedAttributesContext = createContext({
+    getAddedAttributes: undefined,
+    addAddedAttributes: undefined,
+    removeAddedAttribute: undefined,
+    updateAddedAttributeRefEntity: undefined
+});
+var getInitialAttributeValue = function (attrType) {
+    if (isComplexAttribute(attrType) || isImage(attrType))
+        return undefined;
+    var _a = createNewAttributeValue(attrType), value = _a.value, lookupCode = _a.lookupCode;
+    if (value === '' && !lookupCode)
+        return undefined;
+    return lookupCode ? { value: value, lookupCode: lookupCode } : { value: value };
+};
+var generateAddedAttributeId = function (parentId) {
+    return parentId ? "".concat(parentId).concat(ADDED_ID_SEPARATOR).concat(nanoid()) : "".concat(ADDED_CHANGE_ID_PREFIX).concat(nanoid());
+};
+var createAddedAttribute = function (_a) {
+    var attributeType = _a.attributeType, objectUri = _a.objectUri, parentLineId = _a.parentLineId, parentId = _a.parentId, changeOverrides = _a.changeOverrides;
+    var finalChangeOverrides = changeOverrides
+        ? __assign(__assign(__assign({}, changeOverrides), (changeOverrides.attributePath && {
+            attributePath: "".concat(changeOverrides.attributePath, "/").concat(attributeType.name)
+        })), (changeOverrides.refAttributeType && {
+            refAttributeType: "".concat(changeOverrides.refAttributeType, "/attributes/").concat(attributeType.name)
+        })) : undefined;
+    var initialValue = getInitialAttributeValue(attributeType);
+    return __assign({ attributeType: attributeType, id: generateAddedAttributeId(parentId), objectUri: objectUri, parentLineId: parentLineId, parentId: parentId, changeOverrides: finalChangeOverrides }, (initialValue && { initialValue: initialValue }));
+};
+export var AddedAttributesProvider = function (_a) {
+    var children = _a.children;
+    var metadata = useMdmMetadata();
+    var _b = useState([]), state = _b[0], setState = _b[1];
+    var getAddedAttributes = useCallback(function () { return state; }, [state]);
+    var createAddedAttributes = useCallback(function (_a) {
+        var attributeType = _a.attributeType, objectUri = _a.objectUri, parentLineId = _a.parentLineId, parentId = _a.parentId, changeOverrides = _a.changeOverrides;
+        var addedAttribute = createAddedAttribute({
+            attributeType: attributeType,
+            objectUri: objectUri,
+            parentLineId: parentLineId,
+            parentId: parentId,
+            changeOverrides: changeOverrides
+        });
+        var result = [addedAttribute];
+        if (isComplexAttribute(attributeType)) {
+            var subAttributes = getAvailableSubAttributesForNestedOrReference(metadata, attributeType);
+            for (var _i = 0, subAttributes_1 = subAttributes; _i < subAttributes_1.length; _i++) {
+                var attr = subAttributes_1[_i];
+                if (attr.required) {
+                    result.push.apply(result, createAddedAttributes({
+                        attributeType: attr,
+                        objectUri: objectUri,
+                        parentId: addedAttribute.id
+                    }));
+                }
+                else {
+                    result.push(createAddedAttribute({
+                        attributeType: attr,
+                        objectUri: objectUri,
+                        parentId: addedAttribute.id
+                    }));
+                }
+            }
+        }
+        return result;
+    }, [metadata]);
+    var addAddedAttributes = useCallback(function (_a) {
+        var attributeTypes = _a.attributeTypes, objectUri = _a.objectUri, parentLineId = _a.parentLineId, parentId = _a.parentId, changeOverrides = _a.changeOverrides;
+        if (attributeTypes.length === 0)
+            return [];
+        var addedIds = [];
+        setState(function (prev) {
+            var newAddedAttributes = attributeTypes.flatMap(function (attributeType) {
+                return createAddedAttributes({ attributeType: attributeType, objectUri: objectUri, parentLineId: parentLineId, parentId: parentId, changeOverrides: changeOverrides });
+            });
+            addedIds.push.apply(addedIds, newAddedAttributes.map(function (attr) { return attr.id; }));
+            return __spreadArray(__spreadArray([], prev, true), newAddedAttributes, true);
+        });
+        return addedIds;
+    }, [createAddedAttributes]);
+    var removeAddedAttribute = useCallback(function (id) {
+        setState(function (prev) {
+            return prev.filter(function (addedAttribute) {
+                return addedAttribute.id !== id && !addedAttribute.id.startsWith("".concat(id).concat(ADDED_ID_SEPARATOR));
+            });
+        });
+    }, []);
+    var updateAddedAttributeRefEntity = useCallback(function (id, refEntity) {
+        setState(function (prev) { return prev.map(function (attr) { return (attr.id === id ? __assign(__assign({}, attr), { refEntity: refEntity }) : attr); }); });
+    }, []);
+    var value = useMemo(function () { return ({
+        getAddedAttributes: getAddedAttributes,
+        addAddedAttributes: addAddedAttributes,
+        removeAddedAttribute: removeAddedAttribute,
+        updateAddedAttributeRefEntity: updateAddedAttributeRefEntity
+    }); }, [getAddedAttributes, addAddedAttributes, removeAddedAttribute, updateAddedAttributeRefEntity]);
+    return React.createElement(AddedAttributesContext.Provider, { value: value }, children);
+};

package/features/workflow/contexts/ChangeRequestEditorContext/index.d.ts

@@ -1,12 +1,13 @@
 import React from 'react';
-import { AttributeError } from '@reltio/mdm-sdk';
-import { LineData, LineDataValue } from '../../types';
+import type { AttributeError } from '@reltio/mdm-sdk';
+import type { LineData, LineDataValue } from '../../types';
 export type ChangeRequestEditorContextType = {
     updateChange: (lineIds: string[], data: LineDataValue) => void;
     getLineData: (lineId: string) => LineData | undefined;
     getLinesByChangeId: (changeId: string) => Array<[string, LineData]>;
     rejectChange: (lineIds: string[]) => void;
     revertChangeUpdateOrReject: (lineIds: string[]) => void;
+    deleteLineData: (lineIds: string[]) => void;
     getIsParentLineRejected: (lineId: string) => boolean;
     getIsLineRejected: (lineId: string) => boolean;
     getIsLineUpdated: (lineId: string) => boolean;

package/features/workflow/contexts/ChangeRequestEditorContext/index.js

@@ -7,6 +7,7 @@ export var ChangeRequestEditorContext = createContext({
     getLinesByChangeId: undefined,
     rejectChange: undefined,
     revertChangeUpdateOrReject: undefined,
+    deleteLineData: undefined,
     getIsParentLineRejected: undefined,
     getIsLineRejected: undefined,
     getIsLineUpdated: undefined,
@@ -16,6 +17,17 @@ export var ChangeRequestEditorContext = createContext({
     getErrors: undefined
 });
 var emptyArray = [];
+var removeLineDataFromMap = function (map, lineIds) {
+    var newMap = new Map(map);
+    lineIds.forEach(function (id) {
+        newMap.forEach(function (_, key) {
+            if (key.startsWith("".concat(id, "/")) || key === id) {
+                newMap.delete(key);
+            }
+        });
+    });
+    return newMap;
+};
 export var ChangeRequestEditorProvider = function (_a) {
     var children = _a.children;
     var _b = useState(new Map()), lineDataMap = _b[0], setLineDataMap = _b[1];
@@ -40,15 +52,42 @@ export var ChangeRequestEditorProvider = function (_a) {
         });
     }, []);
     var revertChangeUpdateOrReject = useCallback(function (lineIds) {
+        setLineDataMap(function (prevMap) { return removeLineDataFromMap(prevMap, lineIds); });
+    }, []);
+    var deleteLineData = useCallback(function (lineIds) {
         setLineDataMap(function (prevMap) {
-            var newMap = new Map(prevMap);
-            lineIds.forEach(function (id) {
-                newMap.forEach(function (_, key) {
-                    if (key.startsWith("".concat(id, "/")) || key === id) {
-                        newMap.delete(key);
-                    }
+            var newMap = removeLineDataFromMap(prevMap, lineIds);
+            var _loop_1 = function (lineId) {
+                var parts = lineId.split('/');
+                var deletedIndex = parseInt(parts[parts.length - 1]);
+                if (isNaN(deletedIndex))
+                    return "continue";
+                var prefix = parts.slice(0, -1).join('/') + '/';
+                var toRename = [];
+                newMap.forEach(function (data, key) {
+                    if (!key.startsWith(prefix))
+                        return;
+                    var rest = key.slice(prefix.length);
+                    var indexStr = rest.split('/')[0];
+                    var index = parseInt(indexStr);
+                    if (isNaN(index) || index <= deletedIndex)
+                        return;
+                    var newKey = prefix + String(index - 1) + rest.slice(indexStr.length);
+                    toRename.push({ oldKey: key, newKey: newKey, data: data });
                 });
-            });
+                for (var _a = 0, toRename_1 = toRename; _a < toRename_1.length; _a++) {
+                    var oldKey = toRename_1[_a].oldKey;
+                    newMap.delete(oldKey);
+                }
+                for (var _b = 0, toRename_2 = toRename; _b < toRename_2.length; _b++) {
+                    var _c = toRename_2[_b], newKey = _c.newKey, data = _c.data;
+                    newMap.set(newKey, data);
+                }
+            };
+            for (var _i = 0, lineIds_1 = lineIds; _i < lineIds_1.length; _i++) {
+                var lineId = lineIds_1[_i];
+                _loop_1(lineId);
+            }
             return newMap;
         });
     }, []);
@@ -101,6 +140,7 @@ export var ChangeRequestEditorProvider = function (_a) {
         getLinesByChangeId: getLinesByChangeId,
         rejectChange: rejectChange,
         revertChangeUpdateOrReject: revertChangeUpdateOrReject,
+        deleteLineData: deleteLineData,
         getIsParentLineRejected: getIsParentLineRejected,
         getIsLineRejected: getIsLineRejected,
         getIsLineUpdated: getIsLineUpdated,

package/features/workflow/contexts/ScrollToAddedAttributeContext/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type ScrollToAddedAttributeContextType = {
+    highlightedIds: Set<string>;
+    highlight: (addedIds: string[]) => void;
+    scrollToFirst: (ref: React.RefObject<HTMLDivElement>) => void;
+};
+export declare const ScrollToAddedAttributeContext: React.Context<ScrollToAddedAttributeContextType>;
+export declare const ScrollToAddedAttributeProvider: ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export {};

package/features/workflow/contexts/ScrollToAddedAttributeContext/index.js

@@ -0,0 +1,51 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+var EMPTY_SET = new Set();
+var HIGHLIGHT_DURATION_MS = 2000;
+export var ScrollToAddedAttributeContext = React.createContext({
+    highlightedIds: EMPTY_SET,
+    highlight: function () { },
+    scrollToFirst: function () { }
+});
+export var ScrollToAddedAttributeProvider = function (_a) {
+    var children = _a.children;
+    var _b = useState(EMPTY_SET), highlightedIds = _b[0], setHighlightedIds = _b[1];
+    var highlightTimer = useRef(null);
+    var highlightDelay = useRef(null);
+    var bestScrollTarget = useRef(null);
+    var scrollRafId = useRef(0);
+    var highlight = useCallback(function (addedIds) {
+        if (addedIds.length === 0)
+            return;
+        bestScrollTarget.current = null;
+        clearTimeout(highlightTimer.current);
+        clearTimeout(highlightDelay.current);
+        highlightDelay.current = setTimeout(function () {
+            setHighlightedIds(new Set(addedIds));
+            highlightTimer.current = setTimeout(function () { return setHighlightedIds(EMPTY_SET); }, HIGHLIGHT_DURATION_MS);
+        }, 300);
+    }, []);
+    var scrollToFirst = useCallback(function (ref) {
+        if (!ref.current)
+            return;
+        var el = ref.current;
+        if (!bestScrollTarget.current ||
+            el.getBoundingClientRect().top < bestScrollTarget.current.getBoundingClientRect().top) {
+            bestScrollTarget.current = el;
+        }
+        cancelAnimationFrame(scrollRafId.current);
+        scrollRafId.current = requestAnimationFrame(function () {
+            var _a, _b;
+            (_b = (_a = bestScrollTarget.current) === null || _a === void 0 ? void 0 : _a.scrollIntoView) === null || _b === void 0 ? void 0 : _b.call(_a, { behavior: 'smooth', block: 'center' });
+            bestScrollTarget.current = null;
+        });
+    }, []);
+    useEffect(function () {
+        return function () {
+            clearTimeout(highlightTimer.current);
+            clearTimeout(highlightDelay.current);
+            cancelAnimationFrame(scrollRafId.current);
+        };
+    }, []);
+    var value = useMemo(function () { return ({ highlightedIds: highlightedIds, highlight: highlight, scrollToFirst: scrollToFirst }); }, [highlightedIds, highlight, scrollToFirst]);
+    return React.createElement(ScrollToAddedAttributeContext.Provider, { value: value }, children);
+};

package/features/workflow/helpers/attributes.js

@@ -14,6 +14,8 @@ import { DataTypes, DCRTypes, getAttributeTypeSubAttributes, getLabel, getRelati
 import { getFilteredAttrTypes } from '../../../helpers/attributesView';
 import { getOperationType } from './common';
 var getValues = function (attributes, attrType) {
+    if (!attributes || typeof attributes !== 'object')
+        return [];
     if ('newValue' in attributes || 'oldValue' in attributes) {
         var newValue = attributes.newValue, oldValue = attributes.oldValue, type_1 = attributes.type;
         var newAttrValues_1 = pathOr([], ['value', attrType.name])(newValue);
@@ -62,16 +64,23 @@ var dcrAttributesFactory = function (metadata, attributeType, attributeValue, le
     }
 };
 var extractLineIds = function (attributeValue) {
-    var _a, _b;
-    var lineIds = (_b = (_a = attributeValue === null || attributeValue === void 0 ? void 0 : attributeValue.value) === null || _a === void 0 ? void 0 : _a.newValue) === null || _b === void 0 ? void 0 : _b.lineIds;
+    var _a;
+    var innerChange = attributeValue === null || attributeValue === void 0 ? void 0 : attributeValue.value;
+    var lineIds = (_a = innerChange === null || innerChange === void 0 ? void 0 : innerChange.newValue) === null || _a === void 0 ? void 0 : _a.lineIds;
     return Array.isArray(lineIds) ? lineIds : attributeValue.lineIds;
 };
+var extractAddedId = function (attributeValue) {
+    var _a, _b, _c, _d;
+    var innerChange = attributeValue.value;
+    return ((_d = (_b = (_a = innerChange === null || innerChange === void 0 ? void 0 : innerChange.newValue) === null || _a === void 0 ? void 0 : _a.addedId) !== null && _b !== void 0 ? _b : (_c = attributeValue.newValue) === null || _c === void 0 ? void 0 : _c.addedId) !== null && _d !== void 0 ? _d : attributeValue.addedId);
+};
 var getNestedAttributeChange = function (metadata, attributeType, attributeValue, level) {
     var attributeTypeList = getAttributeTypeSubAttributes({}, attributeType);
     var label = getLabel((attributeType === null || attributeType === void 0 ? void 0 : attributeType.label) || (attributeType === null || attributeType === void 0 ? void 0 : attributeType.name));
     var lineIds = extractLineIds(attributeValue);
+    var addedId = extractAddedId(attributeValue);
     return [
-        { level: level, label: label, attributeType: attributeType, attributeValue: attributeValue, lineIds: lineIds },
+        __assign({ level: level, label: label, attributeType: attributeType, attributeValue: attributeValue, lineIds: lineIds }, (addedId && { addedId: addedId })),
         getAttributesList(metadata, attributeTypeList, attributeValue.value, level + 1)
     ];
 };
@@ -79,8 +88,9 @@ var getReferenceAttributeChange = function (metadata, attributeType, attributeVa
     var attributeTypeList = getAttributeTypeSubAttributes(metadata, attributeType);
     var label = (attributeType === null || attributeType === void 0 ? void 0 : attributeType.label) || (attributeType === null || attributeType === void 0 ? void 0 : attributeType.name);
     var lineIds = extractLineIds(attributeValue);
+    var addedId = extractAddedId(attributeValue);
     return [
-        { level: level, label: label, attributeType: attributeType, attributeValue: attributeValue, lineIds: lineIds },
+        __assign({ level: level, label: label, attributeType: attributeType, attributeValue: attributeValue, lineIds: lineIds }, (addedId && { addedId: addedId })),
         getAttributesList(metadata, attributeTypeList, attributeValue.value, level + 1, true)
     ];
 };
@@ -94,16 +104,9 @@ var getSimpleAttributeChange = function (attributeType, attributeValue, level, i
     if (isReferenceSubAttribute === void 0) { isReferenceSubAttribute = false; }
     var _a = getDiffParameters(attributeValue), newValue = _a.newValue, oldValue = _a.oldValue, type = _a.type, newPinOrIgnoreValue = _a.newPinOrIgnoreValue;
     var operation = getOperationType(type, newPinOrIgnoreValue);
+    var addedId = extractAddedId(attributeValue);
     var label = (attributeType === null || attributeType === void 0 ? void 0 : attributeType.label) || (attributeType === null || attributeType === void 0 ? void 0 : attributeType.name);
-    return {
-        attributeType: attributeType,
-        newValue: newValue,
-        oldValue: oldValue,
-        operation: operation,
-        label: label,
-        level: level,
-        isReferenceSubAttribute: isReferenceSubAttribute
-    };
+    return __assign(__assign(__assign(__assign({ attributeType: attributeType, newValue: newValue, oldValue: oldValue, operation: operation, label: label, level: level, isReferenceSubAttribute: isReferenceSubAttribute }, (addedId && { addedId: addedId })), (attributeValue.attributePath && { attributePath: attributeValue.attributePath })), (attributeValue.refAttributeType && { refAttributeType: attributeValue.refAttributeType })), (attributeValue.refObjectURI && { refObjectURI: attributeValue.refObjectURI }));
 };
 export var getEntityChanges = curry(function (metadata, entityInfo, changes) {
     var attrTypes = getFilteredAttrTypes(metadata, entityInfo.type, [], []);

package/features/workflow/helpers/attributes.test.js

@@ -94,7 +94,8 @@ describe('attributes helpers tests', function () {
                 level: 0,
                 newValue: __assign(__assign({}, changes.CountryCode[0].value.newValue), { lineIds: ['3AqlrpfGa/value/oldValue'] }),
                 operation: 'ignored',
-                isReferenceSubAttribute: false
+                isReferenceSubAttribute: false,
+                attributePath: 'CountryCode/3AqlrpfGa'
             },
             {
                 attributeType: metadata.entityTypes[0].attributes[1],
@@ -102,7 +103,8 @@ describe('attributes helpers tests', function () {
                 level: 0,
                 newValue: changes.CountryCode[1].value.newValue,
                 operation: 'added',
-                isReferenceSubAttribute: false
+                isReferenceSubAttribute: false,
+                attributePath: 'CountryCode'
             },
             {
                 attributeType: metadata.entityTypes[0].attributes[3],
@@ -116,7 +118,8 @@ describe('attributes helpers tests', function () {
                 level: 1,
                 newValue: changes.Identifiers[0].value.Type[0].value.newValue,
                 operation: 'ignored',
-                isReferenceSubAttribute: false
+                isReferenceSubAttribute: false,
+                attributePath: 'Identifiers/45uypcuAz/Type/45uypcyRF'
             }
         ]);
     });

package/features/workflow/helpers/dcr.d.ts

@@ -1,5 +1,6 @@
-import { AttributeDelete, ChangeRequest, DCRChange, DCRChanges, DCRObjectInfo, DCRObjectsInfo, GroupedObjectsInfo, Metadata } from '@reltio/mdm-sdk';
+import { AttributeDelete, AttributeInsert, ChangeRequest, DCRChange, DCRChanges, DCRObjectInfo, DCRObjectsInfo, EndDateUpdate, Entity, GroupedObjectsInfo, Metadata, RolesUpdate, StartDateUpdate, TagsUpdate } from '@reltio/mdm-sdk';
 import { LineData } from '../types';
+type CumulativeUpdateDiffEntry = AttributeInsert | EndDateUpdate | StartDateUpdate | TagsUpdate | RolesUpdate;
 export declare const getEntitiesObjects: any;
 export declare const getRelationsObjects: any;
 export declare const extractObjectsFromChangeRequest: (changes: DCRChanges, objectsInfo: DCRObjectsInfo) => DCRObjectInfo[];
@@ -13,4 +14,8 @@ export declare const buildDCRSavePlan: (changes: DCRChanges, getLinesByChangeId:
     updatedChanges: Record<string, DCRChange[]>;
     deleteEntityAttributes: Record<string, AttributeDelete[]>;
     deleteRelationAttributes: Record<string, AttributeDelete[]>;
+    insertEntityAttributes: Record<string, CumulativeUpdateDiffEntry[]>;
+    insertRelationAttributes: Record<string, CumulativeUpdateDiffEntry[]>;
 };
+export declare const mergeExistingRolesAndTags: (diff: CumulativeUpdateDiffEntry[], entity: Entity) => CumulativeUpdateDiffEntry[];
+export {};