@reltio/components 1.4.2260 → 1.4.2261

package/AttributesValuesEditor/AttributesValuesEditor.js

@@ -1,6 +1,7 @@
 import React, { memo, useMemo, useCallback } from 'react';
-import { checkIfOptionHasValues, getAttrDataTypeDefinition, getDataTypeDefinitionForFilterValue } from '@reltio/mdm-sdk';
+import { checkIfOptionHasValues, getAttrDataTypeDefinition, getDataTypeDefinitionForFilterValue, shouldDisableTimestampLocalizationForAttribute } from '@reltio/mdm-sdk';
 import { FilterValueEditor } from '../FilterValueEditor';
+import { useMdmDisableTimestampLocalization } from '../contexts/MdmModuleContext';
 import { useStyles } from './styles';
 var AttributesValuesEditor = function (_a) {
     var rowData = _a.rowData, rowContext = _a.rowContext;
@@ -8,8 +9,13 @@ var AttributesValuesEditor = function (_a) {
     var canFilterAcceptValues = (rowData === null || rowData === void 0 ? void 0 : rowData.attribute) && checkIfOptionHasValues(rowData.filter);
     var changeFilter = rowContext.changeFilter;
     var _b = (rowData || {}), _c = _b.values, values = _c === void 0 ? [] : _c, _d = _b.attribute, _e = _d === void 0 ? {} : _d, attrType = _e.attrType, _f = _e.fieldName, fieldName = _f === void 0 ? null : _f, filter = _b.filter, id = _b.id, operator = _b.operator;
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalization = shouldDisableTimestampLocalizationForAttribute(attrType, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
     var valueDataTypeDefinition = attrType && getAttrDataTypeDefinition(attrType);
-    var filterValueDataTypeDefinition = valueDataTypeDefinition && getDataTypeDefinitionForFilterValue(valueDataTypeDefinition, filter);
+    var filterValueDataTypeDefinition = valueDataTypeDefinition &&
+        getDataTypeDefinitionForFilterValue(valueDataTypeDefinition, filter, { disableTimestampLocalization: disableTimestampLocalization });
     var editorFilter = useMemo(function () { return ({
         filter: filter,
         fieldName: fieldName,

package/DataTypeValue/DataTypeValue.js

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

package/DataTypeValue/DataTypeValue.test.js

@@ -34,8 +34,8 @@ var setUp = function (props, mdmValues) {
 };
 describe('DataTypeValue tests', function () {
     var checkFormatDataTypeCall = function (_a) {
-        var _b = _a.attributesPresentation, attributesPresentation = _b === void 0 ? defaultAttributesPresentation : _b, _c = _a.dateMask, dateMask = _c === void 0 ? defaultDateMask : _c, _d = _a.dateTimeMask, dateTimeMask = _d === void 0 ? defaultDateTimeMask : _d, dataTypeDefinition = _a.dataTypeDefinition, value = _a.value;
-        expect(formatDataTypeValue).toHaveBeenCalledWith({ attributesPresentation: attributesPresentation, dateMask: dateMask, dateTimeMask: dateTimeMask, dataTypeDefinition: dataTypeDefinition }, value);
+        var _b = _a.attributesPresentation, attributesPresentation = _b === void 0 ? defaultAttributesPresentation : _b, _c = _a.dateMask, dateMask = _c === void 0 ? defaultDateMask : _c, _d = _a.dateTimeMask, dateTimeMask = _d === void 0 ? defaultDateTimeMask : _d, dataTypeDefinition = _a.dataTypeDefinition, _e = _a.disableTimestampLocalization, disableTimestampLocalization = _e === void 0 ? false : _e, value = _a.value;
+        expect(formatDataTypeValue).toHaveBeenCalledWith({ attributesPresentation: attributesPresentation, dateMask: dateMask, dateTimeMask: dateTimeMask, dataTypeDefinition: dataTypeDefinition, disableTimestampLocalization: disableTimestampLocalization }, value);
     };
     afterEach(function () {
         jest.clearAllMocks();
@@ -138,4 +138,28 @@ describe('DataTypeValue tests', function () {
         screen.getByText(value);
         checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value });
     });
+    it('should not crash and keep localization on when dataTypeDefinition has no uri and flag is enabled', function () {
+        var value = '2025-07-09T23:10:09.000+0000';
+        var dataTypeDefinition = { type: 'Timestamp' };
+        var mdmValues = __assign(__assign({}, defaultMdmValues), { disableTimestampLocalization: true });
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition }, mdmValues);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value, disableTimestampLocalization: false });
+    });
+    it('should disable localization for regular Timestamp attribute when flag is enabled', function () {
+        var value = '2025-07-09T23:10:09.000+0000';
+        var dataTypeDefinition = {
+            type: 'Timestamp',
+            uri: 'configuration/entityTypes/Individual/attributes/HireDate'
+        };
+        var mdmValues = __assign(__assign({}, defaultMdmValues), { disableTimestampLocalization: true });
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition }, mdmValues);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value, disableTimestampLocalization: true });
+    });
+    it('should keep localization on for system Timestamp attribute even when flag is enabled', function () {
+        var value = '2025-07-09T23:10:09.000+0000';
+        var dataTypeDefinition = { type: 'Timestamp', uri: 'createdTime' };
+        var mdmValues = __assign(__assign({}, defaultMdmValues), { disableTimestampLocalization: true });
+        setUp({ value: value, dataTypeDefinition: dataTypeDefinition }, mdmValues);
+        checkFormatDataTypeCall({ dataTypeDefinition: dataTypeDefinition, value: value, disableTimestampLocalization: false });
+    });
 });

package/FilterValueEditor/FilterValueEditor.js

@@ -22,17 +22,23 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import React from 'react';
 import i18n from 'ui-i18n';
-import { isDateRangeFilterOption, isMultiValueOption, isRangeFilterOption, mapFilterValue, wrapInArray } from '@reltio/mdm-sdk';
+import { isDateRangeFilterOption, isMultiValueOption, isRangeFilterOption, mapFilterValue, shouldDisableTimestampLocalizationForAttribute, wrapInArray } from '@reltio/mdm-sdk';
 import { pipe } from 'ramda';
 import { DateRangeEditor } from '../DateRangeEditor';
 import { DataTypeValueEditor } from '../DataTypeValueEditor';
+import { useMdmDisableTimestampLocalization } from '../contexts/MdmModuleContext';
 import { RangeDataTypeValueEditor } from './components/RangeDataTypeValueEditor';
 import { fromEditorValue, toEditorValue } from './helpers';
 export var FilterValueEditor = function (_a) {
     var _b = _a.filter, _c = _b.values, values = _c === void 0 ? [] : _c, fieldName = _b.fieldName, filter = _b.filter, onChange = _a.onChange, dataTypeDefinition = _a.dataTypeDefinition, orientation = _a.orientation, TextFieldProps = _a.TextFieldProps, otherProps = __rest(_a, ["filter", "onChange", "dataTypeDefinition", "orientation", "TextFieldProps"]);
     var dataType = dataTypeDefinition.type;
-    var value = mapFilterValue(toEditorValue(dataType))(values[0]);
-    var handleChange = pipe(mapFilterValue(fromEditorValue(dataType)), wrapInArray, onChange);
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalization = shouldDisableTimestampLocalizationForAttribute(dataTypeDefinition, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
+    var conversionOptions = { disableTimestampLocalization: disableTimestampLocalization };
+    var value = mapFilterValue(toEditorValue(dataType, conversionOptions))(values[0]);
+    var handleChange = pipe(mapFilterValue(fromEditorValue(dataType, conversionOptions)), wrapInArray, onChange);
     if (isDateRangeFilterOption(filter)) {
         return (React.createElement(DateRangeEditor, __assign({}, otherProps, { values: value, onChange: handleChange, dataTypeDefinition: dataTypeDefinition, label: i18n.text('Date Range') })));
     }

package/FilterValueEditor/helpers.d.ts

@@ -1,2 +1,6 @@
-export function toEditorValue(dataType: any): (value: any) => any;
-export function fromEditorValue(dataType: any): (value: any) => any;
+export function toEditorValue(dataType: any, { disableTimestampLocalization }?: {
+    disableTimestampLocalization?: boolean;
+}): (value: any) => any;
+export function fromEditorValue(dataType: any, { disableTimestampLocalization }?: {
+    disableTimestampLocalization?: boolean;
+}): (value: any) => any;

package/FilterValueEditor/helpers.js

@@ -1,25 +1,41 @@
 import { DataTypes, isDateRangeValue, utils } from '@reltio/mdm-sdk';
-export var toEditorValue = function (dataType) { return function (value) {
-    switch (dataType) {
-        case DataTypes.TYPE_DATE:
-            return isDateRangeValue(value) ? value : utils.dates.toLocalDate(value);
-        case DataTypes.TYPE_LOCAL_DATE:
-        case DataTypes.TYPE_TIMESTAMP:
-        case DataTypes.TYPE_ACTIVENESS_DATE:
-            return isDateRangeValue(value) ? value : new Date(value);
-        default:
-            return value;
-    }
-}; };
-export var fromEditorValue = function (dataType) { return function (value) {
-    switch (dataType) {
-        case DataTypes.TYPE_DATE:
-            return isDateRangeValue(value) ? value : Date.UTC(value.getFullYear(), value.getMonth(), value.getDate());
-        case DataTypes.TYPE_LOCAL_DATE:
-        case DataTypes.TYPE_ACTIVENESS_DATE:
-        case DataTypes.TYPE_TIMESTAMP:
-            return isDateRangeValue(value) ? value : value.valueOf();
-        default:
-            return value;
-    }
-}; };
+export var toEditorValue = function (dataType, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.disableTimestampLocalization, disableTimestampLocalization = _c === void 0 ? false : _c;
+    return function (value) {
+        switch (dataType) {
+            case DataTypes.TYPE_DATE:
+                return isDateRangeValue(value) ? value : utils.dates.toLocalDate(value);
+            case DataTypes.TYPE_TIMESTAMP:
+                if (isDateRangeValue(value)) {
+                    return value;
+                }
+                return disableTimestampLocalization ? utils.dates.toLocalDate(value) : new Date(value);
+            case DataTypes.TYPE_LOCAL_DATE:
+            case DataTypes.TYPE_ACTIVENESS_DATE:
+                return isDateRangeValue(value) ? value : new Date(value);
+            default:
+                return value;
+        }
+    };
+};
+export var fromEditorValue = function (dataType, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.disableTimestampLocalization, disableTimestampLocalization = _c === void 0 ? false : _c;
+    return function (value) {
+        switch (dataType) {
+            case DataTypes.TYPE_DATE:
+                return isDateRangeValue(value)
+                    ? value
+                    : Date.UTC(value.getFullYear(), value.getMonth(), value.getDate());
+            case DataTypes.TYPE_TIMESTAMP:
+                if (isDateRangeValue(value)) {
+                    return value;
+                }
+                return disableTimestampLocalization ? utils.dates.toUtcDate(value).getTime() : value.valueOf();
+            case DataTypes.TYPE_LOCAL_DATE:
+            case DataTypes.TYPE_ACTIVENESS_DATE:
+                return isDateRangeValue(value) ? value : value.valueOf();
+            default:
+                return value;
+        }
+    };
+};

package/FilterValueEditor/helpers.test.d.ts

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

package/FilterValueEditor/helpers.test.js

@@ -0,0 +1,30 @@
+import { DataTypes } from '@reltio/mdm-sdk';
+import { fromEditorValue, toEditorValue } from './helpers';
+describe('FilterValueEditor helpers', function () {
+    describe('TYPE_TIMESTAMP', function () {
+        it('toEditorValue returns Date constructed from value when flag is off', function () {
+            var ms = Date.UTC(2020, 1, 20, 7, 0, 0);
+            expect(toEditorValue(DataTypes.TYPE_TIMESTAMP)(ms)).toEqual(new Date(ms));
+        });
+        it('toEditorValue uses toLocalDate when flag is on (numeric input)', function () {
+            var ms = Date.UTC(2020, 1, 20, 7, 0, 0);
+            var result = toEditorValue(DataTypes.TYPE_TIMESTAMP, { disableTimestampLocalization: true })(ms);
+            var utcDate = new Date(ms);
+            var expected = new Date(utcDate.getUTCFullYear(), utcDate.getUTCMonth(), utcDate.getUTCDate(), utcDate.getUTCHours(), utcDate.getUTCMinutes(), utcDate.getUTCSeconds(), utcDate.getUTCMilliseconds());
+            expect(result.getTime()).toBe(expected.getTime());
+        });
+        it('fromEditorValue returns local epoch ms when flag is off', function () {
+            var localDate = new Date(2020, 1, 20, 7, 0, 0);
+            expect(fromEditorValue(DataTypes.TYPE_TIMESTAMP)(localDate)).toBe(localDate.valueOf());
+        });
+        it('fromEditorValue preserves local parts as UTC when flag is on', function () {
+            var localDate = new Date(2020, 1, 20, 7, 0, 0);
+            var result = fromEditorValue(DataTypes.TYPE_TIMESTAMP, { disableTimestampLocalization: true })(localDate);
+            expect(result).toBe(Date.UTC(localDate.getFullYear(), localDate.getMonth(), localDate.getDate(), localDate.getHours(), localDate.getMinutes(), localDate.getSeconds(), localDate.getMilliseconds()));
+        });
+        it('passes through DateRange values regardless of flag', function () {
+            expect(toEditorValue(DataTypes.TYPE_TIMESTAMP, { disableTimestampLocalization: true })('lastDay')).toBe('lastDay');
+            expect(fromEditorValue(DataTypes.TYPE_TIMESTAMP, { disableTimestampLocalization: true })('lastDay')).toBe('lastDay');
+        });
+    });
+});

package/HOCs/withFilter/components/ColumnFilter/ColumnFilter.js

@@ -1,11 +1,12 @@
 import React, { useEffect, useRef, useState } from 'react';
 import { defaultTo, pipe, prop, propEq } from 'ramda';
-import { checkBasicMetadataPermission, getDataTypeDefinitionForFilterValue, getFilterOptionLabel, getFilterOptionsForDataTypeDefinition, MetadataPermissions, validateFilter } from '@reltio/mdm-sdk';
+import { checkBasicMetadataPermission, getDataTypeDefinitionForFilterValue, getFilterOptionLabel, getFilterOptionsForDataTypeDefinition, MetadataPermissions, shouldDisableTimestampLocalizationForAttribute, validateFilter } from '@reltio/mdm-sdk';
 import Popover from '@mui/material/Popover';
 import IconButton from '@mui/material/IconButton';
 import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
 import { FilterChip } from '../FilterChip';
 import { FilterEditor } from '../../../../FilterEditor';
+import { useMdmDisableTimestampLocalization } from '../../../../contexts/MdmModuleContext';
 import { columnFilterToMdmFilter } from '../../../../helpers/basicTable';
 import { mdmFilterToColumnFilter } from './helpers';
 import { useStyles } from '../../styles';
@@ -13,6 +14,8 @@ export var ColumnFilter = function (_a) {
     var _b;
     var columnId = _a.columnId, dataTypeDefinition = _a.dataTypeDefinition, filter = _a.filter, filterOptionsData = _a.filterOptionsData, onFilter = _a.onFilter;
     var styles = useStyles();
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalizationForFilterValue = shouldDisableTimestampLocalizationForAttribute(dataTypeDefinition, { disableTimestampLocalization: disableTimestampLocalizationFlag });
     var _c = useState(null), anchorEl = _c[0], setAnchorEl = _c[1];
     var openFilterPopup = function (event) { return setAnchorEl(event.currentTarget); };
     var closeFilterPopup = function () { return setAnchorEl(null); };
@@ -21,7 +24,9 @@ export var ColumnFilter = function (_a) {
         setColumnFilter(filter);
     }, [filter]);
     var containerRef = useRef(null);
-    var mdmFilter = columnFilterToMdmFilter({ id: columnId, dataTypeDefinition: dataTypeDefinition }, columnFilter);
+    var mdmFilter = columnFilterToMdmFilter({ id: columnId, dataTypeDefinition: dataTypeDefinition }, columnFilter, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
     var applyFilterChange = function (newFilter) {
         if (newFilter !== filter) {
             onFilter({ columnId: columnId, filter: newFilter });
@@ -52,7 +57,9 @@ export var ColumnFilter = function (_a) {
         return pipe(getFilterOptionData, prop('label'), defaultTo(getFilterOptionLabel(filterOption)))(filterOption);
     };
     var getFilterDataTypeDefinition = function (filterOption) {
-        return pipe(getFilterOptionData, prop('dataTypeDefinition'), defaultTo(getDataTypeDefinitionForFilterValue(dataTypeDefinition, filterOption)))(filterOption);
+        return pipe(getFilterOptionData, prop('dataTypeDefinition'), defaultTo(getDataTypeDefinitionForFilterValue(dataTypeDefinition, filterOption, {
+            disableTimestampLocalization: disableTimestampLocalizationForFilterValue
+        })))(filterOption);
     };
     var filterOptionValues = (_b = filterOptionsData === null || filterOptionsData === void 0 ? void 0 : filterOptionsData.map(function (filterOption) { return filterOption.value; })) !== null && _b !== void 0 ? _b : getFilterOptionsForDataTypeDefinition(dataTypeDefinition);
     var filterOptions = filterOptionValues.map(function (value) { return ({ value: value, label: getFilterLabel(value) }); });

package/HOCs/withFilter/components/FilterChip/FilterChip.js

@@ -1,8 +1,8 @@
 import React from 'react';
 import Chip from '@mui/material/Chip';
-import { checkIfOptionHasValues, formatDataTypeValue, getFilterValueLabel, mapFilterValue } from '@reltio/mdm-sdk';
+import { checkIfOptionHasValues, formatDataTypeValue, getFilterValueLabel, mapFilterValue, shouldDisableTimestampLocalizationForAttribute } from '@reltio/mdm-sdk';
 import { ExpandedValueTooltip } from '../../../../ExpandedValueTooltip';
-import { useMdmAttributesPresentation, useMdmDateMask, useMdmDateTimeMask } from '../../../../contexts/MdmModuleContext';
+import { useMdmAttributesPresentation, useMdmDateMask, useMdmDateTimeMask, useMdmDisableTimestampLocalization } from '../../../../contexts/MdmModuleContext';
 import { useStyles } from './styles';
 export var FilterChip = function (_a) {
     var filterOption = _a.filterOption, filterValue = _a.filterValue, onDelete = _a.onDelete, dataTypeDefinition = _a.dataTypeDefinition;
@@ -10,9 +10,19 @@ export var FilterChip = function (_a) {
     var attributesPresentation = useMdmAttributesPresentation();
     var dateMask = useMdmDateMask();
     var dateTimeMask = useMdmDateTimeMask();
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalization = shouldDisableTimestampLocalizationForAttribute(dataTypeDefinition, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
     var canFilterAcceptValues = checkIfOptionHasValues(filterOption.value);
     var optionLabel = filterOption.label + (canFilterAcceptValues ? ': ' : '');
-    var formatValue = formatDataTypeValue({ attributesPresentation: attributesPresentation, dataTypeDefinition: dataTypeDefinition, dateMask: dateMask, dateTimeMask: dateTimeMask });
+    var formatValue = formatDataTypeValue({
+        attributesPresentation: attributesPresentation,
+        dataTypeDefinition: dataTypeDefinition,
+        dateMask: dateMask,
+        dateTimeMask: dateTimeMask,
+        disableTimestampLocalization: disableTimestampLocalization
+    });
     var convertedValue = mapFilterValue(formatValue, filterValue);
     var filterLabel = canFilterAcceptValues ? getFilterValueLabel(filterOption.value, convertedValue) : '';
     return (React.createElement(Chip, { label: React.createElement(ExpandedValueTooltip, { value: optionLabel + filterLabel },

package/InlineSimpleAttributeEditor/InlineSimpleAttributeEditor.js

@@ -11,11 +11,12 @@ var __assign = (this && this.__assign) || function () {
 };
 import React, { useState } from 'react';
 import Popover from '@mui/material/Popover';
-import { attributeUriToSearchUri, DataTypes, getAttrDataTypeDefinition, isBooleanType, isLookupAttrType, isNumericType, isTimestampBasedType } from '@reltio/mdm-sdk';
+import { attributeUriToSearchUri, DataTypes, getAttrDataTypeDefinition, isBooleanType, isLookupAttrType, isNumericType, isTimestampBasedType, shouldDisableTimestampLocalizationForAttribute } from '@reltio/mdm-sdk';
 import classnames from 'classnames';
 import { equals, isNil } from 'ramda';
 import { DataTypeValueEditor } from '../DataTypeValueEditor';
 import { attributeValueToEditorValue, editorValueToAttributeValue } from '../helpers/attributesView';
+import { useMdmDisableTimestampLocalization } from '../contexts/MdmModuleContext';
 import { useStyles } from './styles';
 var DATA_TYPES_WITH_MULTILINE_EDITOR = [DataTypes.TYPE_TEXT, DataTypes.TYPE_BLOB];
 export var InlineSimpleAttributeEditor = function (_a) {
@@ -26,7 +27,13 @@ export var InlineSimpleAttributeEditor = function (_a) {
         containerWidth: containerRef.current ? containerRef.current.getBoundingClientRect().width : 0
     });
     var dataTypeDefinition = getAttrDataTypeDefinition(attributeType);
-    var initEditorValue = attributeValueToEditorValue(attributeValue, dataTypeDefinition);
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalization = shouldDisableTimestampLocalizationForAttribute(attributeType, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
+    var initEditorValue = attributeValueToEditorValue(attributeValue, dataTypeDefinition, {
+        disableTimestampLocalization: disableTimestampLocalization
+    });
     var _c = useState(initEditorValue), editorValue = _c[0], changeEditorValue = _c[1];
     var isTemporaryWithDefaultValue = !isNil(attributeType.defaultValue) && isTemporary;
     var TextFieldProps = {
@@ -42,7 +49,8 @@ export var InlineSimpleAttributeEditor = function (_a) {
         autoFocus: true
     };
     var applyChangesAndClose = function () {
-        var editedValue = !isNil(editorValue) && editorValueToAttributeValue(attributeType, editorValue);
+        var editedValue = !isNil(editorValue) &&
+            editorValueToAttributeValue(attributeType, editorValue, { disableTimestampLocalization: disableTimestampLocalization });
         if ((!isNil(editorValue) && !equals(editorValue, initEditorValue)) || isTemporaryWithDefaultValue) {
             var editedAttributeValue = isLookupAttrType(attributeType)
                 ? {
@@ -50,7 +58,9 @@ export var InlineSimpleAttributeEditor = function (_a) {
                     lookupCode: editedValue.lookupCode
                 }
                 : {
-                    value: editorValue === '' && isNumericType(dataTypeDefinition.type) ? null : editedValue
+                    value: (editorValue === '' && isNumericType(dataTypeDefinition.type)
+                        ? null
+                        : editedValue)
                 };
             onEdit(__assign(__assign({}, attributeValue), editedAttributeValue));
         }

package/SimpleAttributeEditor/SimpleAttributeEditor.js

@@ -28,7 +28,7 @@ import AddIcon from '@mui/icons-material/Add';
 import DeleteIcon from '@mui/icons-material/Delete';
 import Typography from '@mui/material/Typography';
 import i18n from 'ui-i18n';
-import { attributeUriToSearchUri, ErrorType, getAttributeValue, getAttrDataTypeDefinition, getErrorId, getErrorMessage, getErrorType, isDependentLookupAttrType, isEditableMode as checkIsEditableMode, Mode, DataTypes } from '@reltio/mdm-sdk';
+import { attributeUriToSearchUri, ErrorType, getAttributeValue, getAttrDataTypeDefinition, getErrorId, getErrorMessage, getErrorType, isDependentLookupAttrType, isEditableMode as checkIsEditableMode, shouldDisableTimestampLocalizationForAttribute, Mode, DataTypes } from '@reltio/mdm-sdk';
 import { DataTypeValue } from '../DataTypeValue';
 import { DataTypeValueEditor } from '../DataTypeValueEditor';
 import { ErrorWrapper } from '../ErrorWrapper';
@@ -39,7 +39,7 @@ import { withAsyncMount } from '../HOCs/withAsyncMount';
 import { withContext } from '../HOCs/withContext';
 import { ProfilePerspectiveViewContext } from '../contexts/ProfilePerspectiveViewContext';
 import { ScrollToElementContext, isHighlightedErrorType } from '../contexts/ScrollToElementContext';
-import { useMdmDependentLookupEditorContext } from '../contexts/MdmModuleContext';
+import { useMdmDependentLookupEditorContext, useMdmDisableTimestampLocalization } from '../contexts/MdmModuleContext';
 import { useScrollToAttributeError } from '../hooks/useScrollToAttributeError';
 import { useAutopopulationContextValue } from './useAutopopulationContextValue';
 import { useAttributeValuePermissions } from './useAttributeValuePermissions';
@@ -69,6 +69,10 @@ var SimpleAttributeEditor = function (_a) {
     var showToEdit = canEdit && isEditableMode && !attributeValue.masked;
     var errorMessage = getErrorMessage(ownError);
     var dependentLookupEditorContext = useMdmDependentLookupEditorContext(attributeValue, attributeType);
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalization = shouldDisableTimestampLocalizationForAttribute(attributeType, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
     var isAutocompleteTriggerAttribute = useContextSelector(AddressAutoCompleteContext, function (c) { return c === null || c === void 0 ? void 0 : c.isAutocompleteTriggerAttribute; });
     var _g = useScrollToAttributeError({ highlightedError: highlightedError, isSimple: true }), ref = _g.ref, errorClassName = _g.errorClassName;
     useEffect(function () {
@@ -89,13 +93,13 @@ var SimpleAttributeEditor = function (_a) {
         }
         return dataTypeDefinition;
     }, [attributeType, isAutocompleteTriggerAttribute, isFirstEditor]);
-    var value = useMemo(function () { return attributeValueToEditorValue(attributeValue, dataTypeDefinition); }, [attributeValue, dataTypeDefinition]);
+    var value = useMemo(function () { return attributeValueToEditorValue(attributeValue, dataTypeDefinition, { disableTimestampLocalization: disableTimestampLocalization }); }, [attributeValue, dataTypeDefinition, disableTimestampLocalization]);
     var deactivateError = useCallback(function () {
         if (ownError) {
             onDeactivateError(getErrorId(ownError));
         }
     }, [ownError, onDeactivateError]);
-    var onValueEditorChange = useCallback(pipe(prepareChangeData(attributeValue, attributeType), onChangeAttribute, deactivateError), [attributeValue, attributeType, onChangeAttribute, deactivateError]);
+    var onValueEditorChange = useCallback(pipe(prepareChangeData(attributeValue, attributeType, { disableTimestampLocalization: disableTimestampLocalization }), onChangeAttribute, deactivateError), [attributeValue, attributeType, onChangeAttribute, deactivateError, disableTimestampLocalization]);
     var onDelete = function () {
         onDeleteAttribute({ uri: attributeValue.uri, attributeType: attributeType });
         if (getErrorType(ownError) !== ErrorType.missed) {

package/SimpleAttributeEditor/helpers.d.ts

@@ -1 +1,7 @@
-export declare const prepareChangeData: any;
+import { AttributeType, SimpleAttributeValue } from '@reltio/mdm-sdk';
+import { AttributeValueConversionOptions, EditorValue } from '../helpers/attributesView';
+export declare const prepareChangeData: (attributeValue: SimpleAttributeValue, attributeType: AttributeType, options?: AttributeValueConversionOptions) => (editorValue: EditorValue) => {
+    value: import("@reltio/mdm-sdk").PrimitiveValue | import("@reltio/mdm-sdk").LookupValue;
+    uri: string;
+    attributeType: AttributeType;
+};

package/SimpleAttributeEditor/helpers.js

@@ -1,10 +1,12 @@
-import { curry } from 'ramda';
 import { editorValueToAttributeValue } from '../helpers/attributesView';
-export var prepareChangeData = curry(function (attributeValue, attributeType, editorValue) {
-    var value = editorValueToAttributeValue(attributeType, editorValue);
-    return {
-        value: value,
-        uri: attributeValue.uri,
-        attributeType: attributeType
+export var prepareChangeData = function (attributeValue, attributeType, options) {
+    if (options === void 0) { options = {}; }
+    return function (editorValue) {
+        var value = editorValueToAttributeValue(attributeType, editorValue, options);
+        return {
+            value: value,
+            uri: attributeValue.uri,
+            attributeType: attributeType
+        };
     };
-});
+};

package/SimpleAttributeEditor/helpers.test.js

@@ -1,16 +1,21 @@
-import { DataTypes } from '@reltio/mdm-sdk';
+import { DataTypes, utils } from '@reltio/mdm-sdk';
 import { prepareChangeData } from './helpers';
 describe('helpers', function () {
     describe('prepareChangeData', function () {
+        afterEach(function () {
+            jest.restoreAllMocks();
+        });
         it('should return "true" as a string, if attribute is boolean', function () {
             var attributeValue = {
                 value: 'false',
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Flag',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Flag',
                 type: DataTypes.TYPE_BOOLEAN
             };
-            expect(prepareChangeData(attributeValue, attributeType, true)).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(true)).toEqual({
                 value: 'true',
                 uri: attributeValue.uri,
                 attributeType: attributeType
@@ -22,9 +27,11 @@ describe('helpers', function () {
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Flag',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Flag',
                 type: DataTypes.TYPE_BOOLEAN
             };
-            expect(prepareChangeData(attributeValue, attributeType, false)).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(false)).toEqual({
                 value: 'false',
                 uri: attributeValue.uri,
                 attributeType: attributeType
@@ -36,9 +43,11 @@ describe('helpers', function () {
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Date',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Date',
                 type: DataTypes.TYPE_DATE
             };
-            expect(prepareChangeData(attributeValue, attributeType, new Date('02-14-2019'))).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(new Date('02-14-2019'))).toEqual({
                 value: '2019-02-14',
                 uri: attributeValue.uri,
                 attributeType: attributeType
@@ -50,9 +59,11 @@ describe('helpers', function () {
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Date',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Date',
                 type: DataTypes.TYPE_DATE
             };
-            expect(prepareChangeData(attributeValue, attributeType, null)).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(null)).toEqual({
                 value: '',
                 uri: attributeValue.uri,
                 attributeType: attributeType
@@ -64,9 +75,11 @@ describe('helpers', function () {
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Timestamp',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Timestamp',
                 type: DataTypes.TYPE_TIMESTAMP
             };
-            var value = prepareChangeData(attributeValue, attributeType, new Date('2019-02-14T03:20:40+04:00'));
+            var value = prepareChangeData(attributeValue, attributeType)(new Date('2019-02-14T03:20:40+04:00'));
             expect(value).toMatchObject({
                 uri: attributeValue.uri,
                 attributeType: attributeType,
@@ -79,20 +92,48 @@ describe('helpers', function () {
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Timestamp',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Timestamp',
                 type: DataTypes.TYPE_TIMESTAMP
             };
-            expect(prepareChangeData(attributeValue, attributeType, null)).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(null)).toEqual({
                 value: '',
                 uri: attributeValue.uri,
                 attributeType: attributeType
             });
         });
+        it('routes through utils.dates.toUtcDate when disableTimestampLocalization is on', function () {
+            var toUtcDateSpy = jest.spyOn(utils.dates, 'toUtcDate');
+            var attributeValue = { value: '2018-01-11T07:00:00.000+0000', uri: 'uri1' };
+            var attributeType = {
+                name: 'Timestamp',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Timestamp',
+                type: DataTypes.TYPE_TIMESTAMP
+            };
+            var editorDate = new Date(2019, 1, 14, 3, 20, 40);
+            prepareChangeData(attributeValue, attributeType, { disableTimestampLocalization: true })(editorDate);
+            expect(toUtcDateSpy).toHaveBeenCalledWith(editorDate);
+        });
+        it('does not invoke utils.dates.toUtcDate when flag is off (baseline)', function () {
+            var toUtcDateSpy = jest.spyOn(utils.dates, 'toUtcDate');
+            var attributeValue = { value: '2018-01-11T07:00:00.000+0000', uri: 'uri1' };
+            var attributeType = {
+                name: 'Timestamp',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Timestamp',
+                type: DataTypes.TYPE_TIMESTAMP
+            };
+            var editorDate = new Date(2019, 1, 14, 3, 20, 40);
+            prepareChangeData(attributeValue, attributeType)(editorDate);
+            expect(toUtcDateSpy).not.toHaveBeenCalledWith(editorDate);
+        });
         it('should return new value as is, if attribute is lookup', function () {
             var attributeValue = {
                 value: 'KT',
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Unit',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Unit',
                 type: DataTypes.TYPE_STRING,
                 lookupCode: 'Units Of Measures'
             };
@@ -100,7 +141,7 @@ describe('helpers', function () {
                 value: 'G',
                 lookupCode: 'Units Of Measures'
             };
-            expect(prepareChangeData(attributeValue, attributeType, newValue)).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(newValue)).toEqual({
                 value: newValue,
                 uri: attributeValue.uri,
                 attributeType: attributeType
@@ -112,11 +153,13 @@ describe('helpers', function () {
                 uri: 'uri1'
             };
             var attributeType = {
+                name: 'Unit',
+                uri: 'configuration/entityTypes/HasContacts/attributes/Unit',
                 type: DataTypes.TYPE_STRING,
                 lookupCode: 'Units Of Measures'
             };
             var newValue = null;
-            expect(prepareChangeData(attributeValue, attributeType, newValue)).toEqual({
+            expect(prepareChangeData(attributeValue, attributeType)(newValue)).toEqual({
                 value: '',
                 uri: attributeValue.uri,
                 attributeType: attributeType

package/cjs/AttributesValuesEditor/AttributesValuesEditor.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var react_1 = __importStar(require("react"));
 var mdm_sdk_1 = require("@reltio/mdm-sdk");
 var FilterValueEditor_1 = require("../FilterValueEditor");
+var MdmModuleContext_1 = require("../contexts/MdmModuleContext");
 var styles_1 = require("./styles");
 var AttributesValuesEditor = function (_a) {
     var rowData = _a.rowData, rowContext = _a.rowContext;
@@ -33,8 +34,13 @@ var AttributesValuesEditor = function (_a) {
     var canFilterAcceptValues = (rowData === null || rowData === void 0 ? void 0 : rowData.attribute) && (0, mdm_sdk_1.checkIfOptionHasValues)(rowData.filter);
     var changeFilter = rowContext.changeFilter;
     var _b = (rowData || {}), _c = _b.values, values = _c === void 0 ? [] : _c, _d = _b.attribute, _e = _d === void 0 ? {} : _d, attrType = _e.attrType, _f = _e.fieldName, fieldName = _f === void 0 ? null : _f, filter = _b.filter, id = _b.id, operator = _b.operator;
+    var disableTimestampLocalizationFlag = (0, MdmModuleContext_1.useMdmDisableTimestampLocalization)();
+    var disableTimestampLocalization = (0, mdm_sdk_1.shouldDisableTimestampLocalizationForAttribute)(attrType, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
     var valueDataTypeDefinition = attrType && (0, mdm_sdk_1.getAttrDataTypeDefinition)(attrType);
-    var filterValueDataTypeDefinition = valueDataTypeDefinition && (0, mdm_sdk_1.getDataTypeDefinitionForFilterValue)(valueDataTypeDefinition, filter);
+    var filterValueDataTypeDefinition = valueDataTypeDefinition &&
+        (0, mdm_sdk_1.getDataTypeDefinitionForFilterValue)(valueDataTypeDefinition, filter, { disableTimestampLocalization: disableTimestampLocalization });
     var editorFilter = (0, react_1.useMemo)(function () { return ({
         filter: filter,
         fieldName: fieldName,

package/cjs/DataTypeValue/DataTypeValue.js

@@ -18,7 +18,11 @@ var DataTypeValue = function (_a) {
     var attributesPresentation = (0, MdmModuleContext_1.useMdmAttributesPresentation)();
     var dateMask = (0, MdmModuleContext_1.useMdmDateMask)() || localeDateFormat;
     var dateTimeMask = (0, MdmModuleContext_1.useMdmDateTimeMask)() || localeDateFormat + ' ' + localeTimeFormat;
-    var formattedValue = (0, mdm_sdk_1.formatDataTypeValue)({ attributesPresentation: attributesPresentation, dataTypeDefinition: dataTypeDefinition, dateMask: dateMask, dateTimeMask: dateTimeMask }, value);
+    var disableTimestampLocalizationFlag = (0, MdmModuleContext_1.useMdmDisableTimestampLocalization)();
+    var disableTimestampLocalization = (0, mdm_sdk_1.shouldDisableTimestampLocalizationForAttribute)(dataTypeDefinition, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
+    var formattedValue = (0, mdm_sdk_1.formatDataTypeValue)({ attributesPresentation: attributesPresentation, dataTypeDefinition: dataTypeDefinition, dateMask: dateMask, dateTimeMask: dateTimeMask, disableTimestampLocalization: disableTimestampLocalization }, value);
     return rich && (0, mdm_sdk_1.isAttributeValueLink)(dataTypeDefinition, value) ? (react_1.default.createElement(Link_1.default, { target: "_blank", href: (0, mdm_sdk_1.addProtocolToLink)(formattedValue), underline: "none" },
         react_1.default.createElement(SearchHighlighter_1.SearchHighlighter, { text: formattedValue }))) : (react_1.default.createElement(SearchHighlighter_1.SearchHighlighter, { text: formattedValue }));
 };