@reltio/components 1.4.2276 → 1.4.2277

package/MatchRulesBlock/MatchRulesBlock.d.ts

@@ -1,10 +1,11 @@
 import React from 'react';
-import { Entity, Metadata, Match, EntitiesMap } from '@reltio/mdm-sdk';
+import { Entity, Metadata, EntitiesMap } from '@reltio/mdm-sdk';
 import { MatchRuleVariant } from '../types';
+import type { MatchWithRuleLabels } from '../hooks/useMatchesLoader/types';
 type Props = {
     entitiesMap: EntitiesMap;
     entity: Entity;
-    match: Match;
+    match: MatchWithRuleLabels;
     metadata: Metadata;
     variant?: MatchRuleVariant;
 };

package/MatchRulesBlock/MatchRulesBlock.js

@@ -1,3 +1,14 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import React from 'react';
 import { getMatchRules, getTransitiveMatchRules, isTransitiveMatch, NOT_MATCH } from '@reltio/mdm-sdk';
 import { SimpleMatchRulesBlock } from '../SimpleMatchRulesBlock';
@@ -11,7 +22,10 @@ export var MatchRulesBlock = function (_a) {
         return null;
     }
     var isTransitive = isTransitiveMatch(match);
-    var matchRules = getMatchRules(metadata, entity.type, (match.matchRules || []).concat(match.negativeRules || []));
+    var matchRules = getMatchRules(metadata, entity.type, (match.matchRules || []).concat(match.negativeRules || [])).map(function (matchRule) {
+        var _a;
+        return (__assign(__assign({}, matchRule), { label: ((_a = match.matchRuleLabels) === null || _a === void 0 ? void 0 : _a[matchRule.uri]) || matchRule.label }));
+    });
     var rules = matchRules.filter(function (_a) {
         var uri = _a.uri;
         return uri !== NOT_MATCH;

package/MatchRulesBlock/MatchRulesBlock.test.js

@@ -163,6 +163,31 @@ describe('MatchRulesBlock test', function () {
             matchRules: [metadata.entityTypes[0].matchGroups[2]]
         }));
     });
+    it('should use data tenant match rule labels for rules that are not in customer tenant metadata', function () {
+        var _a;
+        var dataTenantMatchRuleUri = 'configuration/entityTypes/HCP/matchGroups/DataTenantRule';
+        var match = {
+            matchRules: [dataTenantMatchRuleUri],
+            matchRuleLabels: (_a = {},
+                _a[dataTenantMatchRuleUri] = 'Data Tenant Match Rule',
+                _a),
+            object: {
+                uri: 'entities/dataTenantEntity',
+                type: 'configuration/entityTypes/HCP',
+                dataTenant: 'dt1'
+            }
+        };
+        render(React.createElement(MatchRulesBlock, { match: match, metadata: metadata, entity: entity, entitiesMap: {} }));
+        expect(mockTransitiveMatchRules).not.toHaveBeenCalled();
+        expect(mockSimpleMatchRulesBuilder).toHaveBeenCalledWith(expect.objectContaining({
+            matchRules: [
+                {
+                    uri: dataTenantMatchRuleUri,
+                    label: 'Data Tenant Match Rule'
+                }
+            ]
+        }));
+    });
     it('should render SimpleMatchRulesBuilder for non transitive match and work correctly with negativeRules', function () {
         render(React.createElement(MatchRulesBlock, { match: potentialMatches[4], metadata: metadata, entity: entity, entitiesMap: {} }));
         expect(mockTransitiveMatchRules).not.toHaveBeenCalled();

package/cjs/MatchRulesBlock/MatchRulesBlock.d.ts

@@ -1,10 +1,11 @@
 import React from 'react';
-import { Entity, Metadata, Match, EntitiesMap } from '@reltio/mdm-sdk';
+import { Entity, Metadata, EntitiesMap } from '@reltio/mdm-sdk';
 import { MatchRuleVariant } from '../types';
+import type { MatchWithRuleLabels } from '../hooks/useMatchesLoader/types';
 type Props = {
     entitiesMap: EntitiesMap;
     entity: Entity;
-    match: Match;
+    match: MatchWithRuleLabels;
     metadata: Metadata;
     variant?: MatchRuleVariant;
 };

package/cjs/MatchRulesBlock/MatchRulesBlock.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,7 +28,10 @@ var MatchRulesBlock = function (_a) {
         return null;
     }
     var isTransitive = (0, mdm_sdk_1.isTransitiveMatch)(match);
-    var matchRules = (0, mdm_sdk_1.getMatchRules)(metadata, entity.type, (match.matchRules || []).concat(match.negativeRules || []));
+    var matchRules = (0, mdm_sdk_1.getMatchRules)(metadata, entity.type, (match.matchRules || []).concat(match.negativeRules || [])).map(function (matchRule) {
+        var _a;
+        return (__assign(__assign({}, matchRule), { label: ((_a = match.matchRuleLabels) === null || _a === void 0 ? void 0 : _a[matchRule.uri]) || matchRule.label }));
+    });
     var rules = matchRules.filter(function (_a) {
         var uri = _a.uri;
         return uri !== mdm_sdk_1.NOT_MATCH;

package/cjs/MatchRulesBlock/MatchRulesBlock.test.js

@@ -168,6 +168,31 @@ describe('MatchRulesBlock test', function () {
             matchRules: [metadata.entityTypes[0].matchGroups[2]]
         }));
     });
+    it('should use data tenant match rule labels for rules that are not in customer tenant metadata', function () {
+        var _a;
+        var dataTenantMatchRuleUri = 'configuration/entityTypes/HCP/matchGroups/DataTenantRule';
+        var match = {
+            matchRules: [dataTenantMatchRuleUri],
+            matchRuleLabels: (_a = {},
+                _a[dataTenantMatchRuleUri] = 'Data Tenant Match Rule',
+                _a),
+            object: {
+                uri: 'entities/dataTenantEntity',
+                type: 'configuration/entityTypes/HCP',
+                dataTenant: 'dt1'
+            }
+        };
+        (0, react_2.render)(react_1.default.createElement(MatchRulesBlock_1.MatchRulesBlock, { match: match, metadata: metadata, entity: entity, entitiesMap: {} }));
+        expect(mockTransitiveMatchRules).not.toHaveBeenCalled();
+        expect(mockSimpleMatchRulesBuilder).toHaveBeenCalledWith(expect.objectContaining({
+            matchRules: [
+                {
+                    uri: dataTenantMatchRuleUri,
+                    label: 'Data Tenant Match Rule'
+                }
+            ]
+        }));
+    });
     it('should render SimpleMatchRulesBuilder for non transitive match and work correctly with negativeRules', function () {
         (0, react_2.render)(react_1.default.createElement(MatchRulesBlock_1.MatchRulesBlock, { match: potentialMatches[4], metadata: metadata, entity: entity, entitiesMap: {} }));
         expect(mockTransitiveMatchRules).not.toHaveBeenCalled();

package/cjs/hooks/useMatchesLoader/types.d.ts

@@ -0,0 +1,4 @@
+import { Match } from '@reltio/mdm-sdk';
+export type MatchWithRuleLabels = Match & {
+    matchRuleLabels?: Record<string, string>;
+};

package/cjs/hooks/useMatchesLoader/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/hooks/useMatchesLoader/useMatchesLoader.d.ts

@@ -1,4 +1,5 @@
-import { Entity, Match, SortingField, EntitiesMap } from '@reltio/mdm-sdk';
+import { Entity, SortingField, EntitiesMap } from '@reltio/mdm-sdk';
+import type { MatchWithRuleLabels } from './types';
 type Props = {
     enabled: boolean;
     entity: Entity;
@@ -17,7 +18,7 @@ type Props = {
 };
 export declare const useMatchesLoader: ({ enabled, entity, filter, rules, onFinishLoading, onStartLoading, options, page, rowsPerPage, sorting, markMatchedValues }: Props) => {
     total: number;
-    matches: Match[];
+    matches: MatchWithRuleLabels[];
     entitiesMap: EntitiesMap<Pick<Entity, "label" | "type" | "uri">>;
     loadMatches: () => void;
 };

package/cjs/hooks/useMatchesLoader/useMatchesLoader.js

@@ -17,18 +17,48 @@ var mdm_sdk_1 = require("@reltio/mdm-sdk");
 var usePagingSimulator_1 = require("../usePagingSimulator");
 var useSafePromise_1 = require("../useSafePromise");
 var MdmModuleContext_1 = require("../../contexts/MdmModuleContext");
+var matchRuleLabelsCache = new Map();
+// Match rule labels are static per (dtssPath, customerTenant), so the request is
+// cached and reused across reloads (paging, filtering, sorting) instead of being
+// refetched every time matches are loaded. Failed requests are evicted so a later
+// load can retry.
+var getCachedDataTenantMatchRuleLabels = function (dtssPath, customerTenant) {
+    var cacheKey = "".concat(dtssPath, "::").concat(customerTenant);
+    var cachedRequest = matchRuleLabelsCache.get(cacheKey);
+    if (cachedRequest !== undefined) {
+        return cachedRequest;
+    }
+    var request = (0, mdm_sdk_1.getDataTenantMatchGroups)({ dtssPath: dtssPath, customerTenant: customerTenant }).catch(function () {
+        matchRuleLabelsCache.delete(cacheKey);
+        return {};
+    });
+    matchRuleLabelsCache.set(cacheKey, request);
+    return request;
+};
+var addDataTenantMatchRuleLabels = function (matches, entity, matchRuleLabels) {
+    if (!Object.keys(matchRuleLabels).length) {
+        return matches;
+    }
+    return matches.map(function (match) {
+        var _a;
+        return ((0, mdm_sdk_1.isDataTenantEntity)(entity) || (0, mdm_sdk_1.isDataTenantEntity)(match.object)) &&
+            ((_a = match.matchRules) === null || _a === void 0 ? void 0 : _a.some(function (matchRuleUri) { return matchRuleLabels[matchRuleUri]; }))
+            ? __assign(__assign({}, match), { matchRuleLabels: matchRuleLabels }) : match;
+    });
+};
 var useMatchesLoader = function (_a) {
     var enabled = _a.enabled, entity = _a.entity, filter = _a.filter, rules = _a.rules, onFinishLoading = _a.onFinishLoading, onStartLoading = _a.onStartLoading, options = _a.options, page = _a.page, rowsPerPage = _a.rowsPerPage, sorting = _a.sorting, markMatchedValues = _a.markMatchedValues;
     var _b = sorting || {}, order = _b.order, field = _b.field;
     var _c = (0, react_1.useState)(0), total = _c[0], setTotal = _c[1];
     var _d = (0, react_1.useState)([]), matches = _d[0], setMatches = _d[1];
-    var _e = (0, react_1.useState)({}), entitiesMap = _e[0], setEntitiesMap = _e[1];
+    var _e = (0, react_1.useState)({}), matchRuleLabels = _e[0], setMatchRuleLabels = _e[1];
+    var _f = (0, react_1.useState)({}), entitiesMap = _f[0], setEntitiesMap = _f[1];
     var metadata = (0, MdmModuleContext_1.useMdmMetadata)();
     var tenant = (0, MdmModuleContext_1.useMdmTenant)();
     var dtssPath = (0, MdmModuleContext_1.useMdmDtssPath)();
     var dataTenants = (0, MdmModuleContext_1.useMdmDataTenantsWithIdBuilder)();
     var showMasking = (0, MdmModuleContext_1.useMdmShowMasking)();
-    var _f = (0, MdmModuleContext_1.useMdmGlobalSearchRequestOptions)() || {}, activityFilter = _f.activityFilter, globalFilter = _f.globalFilter;
+    var _g = (0, MdmModuleContext_1.useMdmGlobalSearchRequestOptions)() || {}, activityFilter = _g.activityFilter, globalFilter = _g.globalFilter;
     var activeness = typeof options.showInactiveEntities === 'boolean'
         ? options.showInactiveEntities
             ? mdm_sdk_1.ActivityFilter.ALL
@@ -51,6 +81,7 @@ var useMatchesLoader = function (_a) {
     var getTransitiveMatchesWithPaging = (0, usePagingSimulator_1.usePagingSimulator)(getTransitiveMatchesWithDtss);
     var getPagedMatchesForDataTenantEntity = (0, usePagingSimulator_1.usePagingSimulator)(mdm_sdk_1.getMatchesForDataTenantEntity);
     var safePromise = (0, useSafePromise_1.useSafePromise)();
+    var safeMatchRuleLabelsPromise = (0, useSafePromise_1.useSafePromise)();
     var getMatches = (0, react_1.useCallback)(function (force) {
         if (force === void 0) { force = false; }
         if (!enabled || (0, mdm_sdk_1.isTempUri)(entityUri)) {
@@ -60,7 +91,7 @@ var useMatchesLoader = function (_a) {
             return;
         }
         onStartLoading === null || onStartLoading === void 0 ? void 0 : onStartLoading();
-        safePromise((0, mdm_sdk_1.isDataTenantEntity)(entity)
+        var matchesRequest = (0, mdm_sdk_1.isDataTenantEntity)(entity)
             ? getPagedMatchesForDataTenantEntity({
                 dtssPath: dtssPath,
                 entity: entity,
@@ -80,7 +111,8 @@ var useMatchesLoader = function (_a) {
                 markMatchedValues: markMatchedValues,
                 deep: options.showTransitiveMatches ? undefined : 1,
                 activeness: activeness
-            }, showMasking)), { offset: page * rowsPerPage, force: force })))
+            }, showMasking)), { offset: page * rowsPerPage, force: force }));
+        safePromise(matchesRequest)
             .then(function (result) {
             var response = result.response, total = result.total, originalResponse = result.originalResponse;
             setTotal(total);
@@ -126,12 +158,27 @@ var useMatchesLoader = function (_a) {
     (0, react_1.useEffect)(function () {
         getMatches();
     }, [getMatches]);
+    // Match rule labels are loaded independently of the matches request so the
+    // matches list renders without waiting for them; they are applied as a
+    // derived layer once available. Keyed on a stable boolean rather than the
+    // dataTenants array reference to avoid re-firing on every render.
+    var hasDataTenants = !!(dataTenants === null || dataTenants === void 0 ? void 0 : dataTenants.length);
+    (0, react_1.useEffect)(function () {
+        if (!dtssPath || !tenant || !hasDataTenants) {
+            setMatchRuleLabels({});
+            return;
+        }
+        safeMatchRuleLabelsPromise(getCachedDataTenantMatchRuleLabels(dtssPath, tenant))
+            .then(setMatchRuleLabels)
+            .catch(function () { return setMatchRuleLabels({}); });
+    }, [dtssPath, tenant, hasDataTenants, safeMatchRuleLabelsPromise]);
+    var matchesWithRuleLabels = (0, react_1.useMemo)(function () { return addDataTenantMatchRuleLabels(matches, entity, matchRuleLabels); }, [matches, entity, matchRuleLabels]);
     var loadMatches = (0, react_1.useCallback)(function () {
         getMatches(true);
     }, [getMatches]);
     return {
         total: total,
-        matches: matches,
+        matches: matchesWithRuleLabels,
         entitiesMap: entitiesMap,
         loadMatches: loadMatches
     };

package/cjs/hooks/useMatchesLoader/useMatchesLoader.test.js

@@ -55,7 +55,7 @@ var mdm_sdk_1 = require("@reltio/mdm-sdk");
 var react_2 = require("@testing-library/react");
 var MdmModuleContext_1 = require("../../contexts/MdmModuleContext");
 var useMatchesLoader_1 = require("./useMatchesLoader");
-jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getTransitiveMatches: jest.fn(), getMatchesForDataTenantEntity: jest.fn(), isDataTenantEntity: jest.fn().mockImplementation(function (entity) { return !!entity.dataTenant; }) })); });
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getTransitiveMatches: jest.fn(), getMatchesForDataTenantEntity: jest.fn(), getDataTenantMatchGroups: jest.fn(), isDataTenantEntity: jest.fn().mockImplementation(function (entity) { return !!entity.dataTenant; }) })); });
 /**
  * useMatchesLoader runs a useEffect that calls getMatches() on mount. getMatches() is async:
  * it calls the SDK (getTransitiveMatches / getMatchesForDataTenantEntity), and when the
@@ -192,4 +192,47 @@ describe('Test useMatchesLoader hook', function () {
             }
         });
     }); });
+    it('should add data tenant match rule labels to DTSS matches', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var matchRuleUri, result;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    matchRuleUri = 'configuration/entityTypes/HCP/matchGroups/DataTenantRule';
+                    mdm_sdk_1.getMatchesForDataTenantEntity.mockResolvedValueOnce([
+                        {
+                            object: {
+                                uri: 'entities/customerTenantMatch',
+                                type: 'configuration/entityTypes/HCP'
+                            },
+                            matchRules: [matchRuleUri]
+                        }
+                    ]);
+                    mdm_sdk_1.getDataTenantMatchGroups.mockResolvedValueOnce((_a = {},
+                        _a[matchRuleUri] = 'Data Tenant Match Rule',
+                        _a));
+                    result = setUp({
+                        props: __assign(__assign({}, defaultProps), { entity: __assign(__assign({}, defaultProps.entity), { dataTenant: 'tenantId4' }) }),
+                        mdmValues: __assign(__assign({}, defaultMdmValues), { dtssPath: 'dtssPath/', tenant: { id: 'customerTenant', name: 'customerTenant' } })
+                    }).result;
+                    return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                            var _a;
+                            expect(result.current.matches).toEqual([
+                                expect.objectContaining({
+                                    matchRuleLabels: (_a = {},
+                                        _a[matchRuleUri] = 'Data Tenant Match Rule',
+                                        _a)
+                                })
+                            ]);
+                        })];
+                case 1:
+                    _b.sent();
+                    expect(mdm_sdk_1.getDataTenantMatchGroups).toHaveBeenCalledWith({
+                        dtssPath: 'dtssPath/',
+                        customerTenant: 'customerTenant'
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/hooks/useMatchesLoader/types.d.ts

@@ -0,0 +1,4 @@
+import { Match } from '@reltio/mdm-sdk';
+export type MatchWithRuleLabels = Match & {
+    matchRuleLabels?: Record<string, string>;
+};

package/hooks/useMatchesLoader/types.js

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

package/hooks/useMatchesLoader/useMatchesLoader.d.ts

@@ -1,4 +1,5 @@
-import { Entity, Match, SortingField, EntitiesMap } from '@reltio/mdm-sdk';
+import { Entity, SortingField, EntitiesMap } from '@reltio/mdm-sdk';
+import type { MatchWithRuleLabels } from './types';
 type Props = {
     enabled: boolean;
     entity: Entity;
@@ -17,7 +18,7 @@ type Props = {
 };
 export declare const useMatchesLoader: ({ enabled, entity, filter, rules, onFinishLoading, onStartLoading, options, page, rowsPerPage, sorting, markMatchedValues }: Props) => {
     total: number;
-    matches: Match[];
+    matches: MatchWithRuleLabels[];
     entitiesMap: EntitiesMap<Pick<Entity, "label" | "type" | "uri">>;
     loadMatches: () => void;
 };

package/hooks/useMatchesLoader/useMatchesLoader.js

@@ -10,22 +10,52 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { ActivityFilter, collectAllTransitiveEntitiesUris, getEntitiesMapForTransitiveMatches, getMatchesForDataTenantEntity, getMatchesFromDataTenants, getTransitiveMatches, isDataTenantEntity, isTempUri, withDtssPotentialItems, addGlobalFilterToQuery, addGetTransitiveMatchesMaskingOptions } from '@reltio/mdm-sdk';
+import { ActivityFilter, collectAllTransitiveEntitiesUris, getEntitiesMapForTransitiveMatches, getDataTenantMatchGroups, getMatchesForDataTenantEntity, getMatchesFromDataTenants, getTransitiveMatches, isDataTenantEntity, isTempUri, withDtssPotentialItems, addGlobalFilterToQuery, addGetTransitiveMatchesMaskingOptions } from '@reltio/mdm-sdk';
 import { usePagingSimulator } from '../usePagingSimulator';
 import { useSafePromise } from '../useSafePromise';
 import { useMdmDataTenantsWithIdBuilder, useMdmDtssPath, useMdmGlobalSearchRequestOptions, useMdmMetadata, useMdmTenant, useMdmShowMasking } from '../../contexts/MdmModuleContext';
+var matchRuleLabelsCache = new Map();
+// Match rule labels are static per (dtssPath, customerTenant), so the request is
+// cached and reused across reloads (paging, filtering, sorting) instead of being
+// refetched every time matches are loaded. Failed requests are evicted so a later
+// load can retry.
+var getCachedDataTenantMatchRuleLabels = function (dtssPath, customerTenant) {
+    var cacheKey = "".concat(dtssPath, "::").concat(customerTenant);
+    var cachedRequest = matchRuleLabelsCache.get(cacheKey);
+    if (cachedRequest !== undefined) {
+        return cachedRequest;
+    }
+    var request = getDataTenantMatchGroups({ dtssPath: dtssPath, customerTenant: customerTenant }).catch(function () {
+        matchRuleLabelsCache.delete(cacheKey);
+        return {};
+    });
+    matchRuleLabelsCache.set(cacheKey, request);
+    return request;
+};
+var addDataTenantMatchRuleLabels = function (matches, entity, matchRuleLabels) {
+    if (!Object.keys(matchRuleLabels).length) {
+        return matches;
+    }
+    return matches.map(function (match) {
+        var _a;
+        return (isDataTenantEntity(entity) || isDataTenantEntity(match.object)) &&
+            ((_a = match.matchRules) === null || _a === void 0 ? void 0 : _a.some(function (matchRuleUri) { return matchRuleLabels[matchRuleUri]; }))
+            ? __assign(__assign({}, match), { matchRuleLabels: matchRuleLabels }) : match;
+    });
+};
 export var useMatchesLoader = function (_a) {
     var enabled = _a.enabled, entity = _a.entity, filter = _a.filter, rules = _a.rules, onFinishLoading = _a.onFinishLoading, onStartLoading = _a.onStartLoading, options = _a.options, page = _a.page, rowsPerPage = _a.rowsPerPage, sorting = _a.sorting, markMatchedValues = _a.markMatchedValues;
     var _b = sorting || {}, order = _b.order, field = _b.field;
     var _c = useState(0), total = _c[0], setTotal = _c[1];
     var _d = useState([]), matches = _d[0], setMatches = _d[1];
-    var _e = useState({}), entitiesMap = _e[0], setEntitiesMap = _e[1];
+    var _e = useState({}), matchRuleLabels = _e[0], setMatchRuleLabels = _e[1];
+    var _f = useState({}), entitiesMap = _f[0], setEntitiesMap = _f[1];
     var metadata = useMdmMetadata();
     var tenant = useMdmTenant();
     var dtssPath = useMdmDtssPath();
     var dataTenants = useMdmDataTenantsWithIdBuilder();
     var showMasking = useMdmShowMasking();
-    var _f = useMdmGlobalSearchRequestOptions() || {}, activityFilter = _f.activityFilter, globalFilter = _f.globalFilter;
+    var _g = useMdmGlobalSearchRequestOptions() || {}, activityFilter = _g.activityFilter, globalFilter = _g.globalFilter;
     var activeness = typeof options.showInactiveEntities === 'boolean'
         ? options.showInactiveEntities
             ? ActivityFilter.ALL
@@ -48,6 +78,7 @@ export var useMatchesLoader = function (_a) {
     var getTransitiveMatchesWithPaging = usePagingSimulator(getTransitiveMatchesWithDtss);
     var getPagedMatchesForDataTenantEntity = usePagingSimulator(getMatchesForDataTenantEntity);
     var safePromise = useSafePromise();
+    var safeMatchRuleLabelsPromise = useSafePromise();
     var getMatches = useCallback(function (force) {
         if (force === void 0) { force = false; }
         if (!enabled || isTempUri(entityUri)) {
@@ -57,7 +88,7 @@ export var useMatchesLoader = function (_a) {
             return;
         }
         onStartLoading === null || onStartLoading === void 0 ? void 0 : onStartLoading();
-        safePromise(isDataTenantEntity(entity)
+        var matchesRequest = isDataTenantEntity(entity)
             ? getPagedMatchesForDataTenantEntity({
                 dtssPath: dtssPath,
                 entity: entity,
@@ -77,7 +108,8 @@ export var useMatchesLoader = function (_a) {
                 markMatchedValues: markMatchedValues,
                 deep: options.showTransitiveMatches ? undefined : 1,
                 activeness: activeness
-            }, showMasking)), { offset: page * rowsPerPage, force: force })))
+            }, showMasking)), { offset: page * rowsPerPage, force: force }));
+        safePromise(matchesRequest)
             .then(function (result) {
             var response = result.response, total = result.total, originalResponse = result.originalResponse;
             setTotal(total);
@@ -123,12 +155,27 @@ export var useMatchesLoader = function (_a) {
     useEffect(function () {
         getMatches();
     }, [getMatches]);
+    // Match rule labels are loaded independently of the matches request so the
+    // matches list renders without waiting for them; they are applied as a
+    // derived layer once available. Keyed on a stable boolean rather than the
+    // dataTenants array reference to avoid re-firing on every render.
+    var hasDataTenants = !!(dataTenants === null || dataTenants === void 0 ? void 0 : dataTenants.length);
+    useEffect(function () {
+        if (!dtssPath || !tenant || !hasDataTenants) {
+            setMatchRuleLabels({});
+            return;
+        }
+        safeMatchRuleLabelsPromise(getCachedDataTenantMatchRuleLabels(dtssPath, tenant))
+            .then(setMatchRuleLabels)
+            .catch(function () { return setMatchRuleLabels({}); });
+    }, [dtssPath, tenant, hasDataTenants, safeMatchRuleLabelsPromise]);
+    var matchesWithRuleLabels = useMemo(function () { return addDataTenantMatchRuleLabels(matches, entity, matchRuleLabels); }, [matches, entity, matchRuleLabels]);
     var loadMatches = useCallback(function () {
         getMatches(true);
     }, [getMatches]);
     return {
         total: total,
-        matches: matches,
+        matches: matchesWithRuleLabels,
         entitiesMap: entitiesMap,
         loadMatches: loadMatches
     };

package/hooks/useMatchesLoader/useMatchesLoader.test.js

@@ -46,11 +46,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import React from 'react';
-import { getTransitiveMatches, getMatchesForDataTenantEntity } from '@reltio/mdm-sdk';
+import { getTransitiveMatches, getMatchesForDataTenantEntity, getDataTenantMatchGroups } from '@reltio/mdm-sdk';
 import { renderHook, waitFor } from '@testing-library/react';
 import { MdmModuleProvider } from '../../contexts/MdmModuleContext';
 import { useMatchesLoader } from './useMatchesLoader';
-jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getTransitiveMatches: jest.fn(), getMatchesForDataTenantEntity: jest.fn(), isDataTenantEntity: jest.fn().mockImplementation(function (entity) { return !!entity.dataTenant; }) })); });
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getTransitiveMatches: jest.fn(), getMatchesForDataTenantEntity: jest.fn(), getDataTenantMatchGroups: jest.fn(), isDataTenantEntity: jest.fn().mockImplementation(function (entity) { return !!entity.dataTenant; }) })); });
 /**
  * useMatchesLoader runs a useEffect that calls getMatches() on mount. getMatches() is async:
  * it calls the SDK (getTransitiveMatches / getMatchesForDataTenantEntity), and when the
@@ -187,4 +187,47 @@ describe('Test useMatchesLoader hook', function () {
             }
         });
     }); });
+    it('should add data tenant match rule labels to DTSS matches', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var matchRuleUri, result;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    matchRuleUri = 'configuration/entityTypes/HCP/matchGroups/DataTenantRule';
+                    getMatchesForDataTenantEntity.mockResolvedValueOnce([
+                        {
+                            object: {
+                                uri: 'entities/customerTenantMatch',
+                                type: 'configuration/entityTypes/HCP'
+                            },
+                            matchRules: [matchRuleUri]
+                        }
+                    ]);
+                    getDataTenantMatchGroups.mockResolvedValueOnce((_a = {},
+                        _a[matchRuleUri] = 'Data Tenant Match Rule',
+                        _a));
+                    result = setUp({
+                        props: __assign(__assign({}, defaultProps), { entity: __assign(__assign({}, defaultProps.entity), { dataTenant: 'tenantId4' }) }),
+                        mdmValues: __assign(__assign({}, defaultMdmValues), { dtssPath: 'dtssPath/', tenant: { id: 'customerTenant', name: 'customerTenant' } })
+                    }).result;
+                    return [4 /*yield*/, waitFor(function () {
+                            var _a;
+                            expect(result.current.matches).toEqual([
+                                expect.objectContaining({
+                                    matchRuleLabels: (_a = {},
+                                        _a[matchRuleUri] = 'Data Tenant Match Rule',
+                                        _a)
+                                })
+                            ]);
+                        })];
+                case 1:
+                    _b.sent();
+                    expect(getDataTenantMatchGroups).toHaveBeenCalledWith({
+                        dtssPath: 'dtssPath/',
+                        customerTenant: 'customerTenant'
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2276",
+  "version": "1.4.2277",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",
@@ -11,7 +11,7 @@
     "@fluentui/react-context-selector": "^9.1.26",
     "@googlemaps/markerclusterer": "^2.5.3",
     "@react-sigma/core": "3.4.0",
-    "@reltio/mdm-sdk": "^1.4.2052",
+    "@reltio/mdm-sdk": "^1.4.2053",
     "@vis.gl/react-google-maps": "^1.3.0",
     "d3-cloud": "^1.2.5",
     "d3-geo": "^2.0.1",