@atlaskit/editor-plugin-show-diff 15.1.1 → 15.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 15.1.2
+
+### Patch Changes
+
+- [`acf9db40862d2`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/acf9db40862d2) -
+  Contributor tags no longer disappear for every actor when a single one cannot be named.
+  `resolveDiffContributors` now skips only the unresolvable actor — its changes keep their diff
+  colour and go untagged — instead of discarding the whole contributor list, and a user-invoked
+  agent is still credited (without the connection) when its invoking user has no profile. Behind the
+  `confluence_ncs_step_diffing_version_history` feature gate and the
+  `platform_editor_show_diff_color_scheme_refactor` experiment.
+
 ## 15.1.1
 
 ### Patch Changes

package/dist/cjs/pm-plugins/resolveDiffContributors.js

@@ -70,8 +70,9 @@ var resolveAgent = function resolveAgent(attribution, profilesByAccountId) {
 
 /**
  * One contributor per distinct actor behind the attributed steps, resolved against the identities
- * the consumer supplied. Returns `undefined` if any actor cannot be named: a half-credited diff
- * reads as "nobody touched this", so the whole list is dropped and the plain diff renders instead.
+ * the consumer supplied. An actor the consumer cannot name is skipped rather than dropping the whole
+ * list: tags are per change, so its changes keep their diff colour and simply carry no tag, while
+ * the actors that *are* named stay credited. Returns `undefined` only when nothing resolves at all.
  */
 var resolveDiffContributors = exports.resolveDiffContributors = function resolveDiffContributors(stepsWithAttribution, profiles) {
   // Profiles opt callers into contributor tags; attribution alone still supplies diff colours.
@@ -110,28 +111,30 @@ var resolveDiffContributors = exports.resolveDiffContributors = function resolve
           userId: userId
         };
         var _user = resolveUser(userId, profilesByAccountId);
-        if (!_user) {
-          return undefined;
-        }
 
         // Skipped if the invoking user's own step already credited them.
         var invokingUserActor = (0, _attributions.getAttributionKey)(invokingUser);
-        if (invokingUserActor && !creditedActors.has(invokingUserActor)) {
+        if (_user && invokingUserActor && !creditedActors.has(invokingUserActor)) {
           contributors.push(_objectSpread(_objectSpread({}, _user), {}, {
             attribution: invokingUser
           }));
           creditedActors.add(invokingUserActor);
         }
+
+        // The agent is always nameable, so it is credited even when its invoker is not — but
+        // without the connection, which would point at a contributor that was never created.
         contributors.push(_objectSpread(_objectSpread({}, agent), {}, {
-          attribution: stepAttribution,
+          attribution: stepAttribution
+        }, _user ? {
           connectedTo: invokingUser
-        }));
+        } : {}));
         creditedActors.add(actor);
         continue;
       }
       var user = userId ? resolveUser(userId, profilesByAccountId) : undefined;
       if (!user) {
-        return undefined;
+        // Unnamed, and a user has no generic fallback label, so this actor's changes go untagged.
+        continue;
       }
       contributors.push(_objectSpread(_objectSpread({}, user), {}, {
         attribution: stepAttribution

package/dist/es2019/pm-plugins/resolveDiffContributors.js

@@ -58,8 +58,9 @@ const resolveAgent = (attribution, profilesByAccountId) => {
 
 /**
  * One contributor per distinct actor behind the attributed steps, resolved against the identities
- * the consumer supplied. Returns `undefined` if any actor cannot be named: a half-credited diff
- * reads as "nobody touched this", so the whole list is dropped and the plain diff renders instead.
+ * the consumer supplied. An actor the consumer cannot name is skipped rather than dropping the whole
+ * list: tags are per change, so its changes keep their diff colour and simply carry no tag, while
+ * the actors that *are* named stay credited. Returns `undefined` only when nothing resolves at all.
  */
 export const resolveDiffContributors = (stepsWithAttribution, profiles) => {
   // Profiles opt callers into contributor tags; attribution alone still supplies diff colours.
@@ -97,30 +98,33 @@ export const resolveDiffContributors = (stepsWithAttribution, profiles) => {
         userId
       };
       const user = resolveUser(userId, profilesByAccountId);
-      if (!user) {
-        return undefined;
-      }
 
       // Skipped if the invoking user's own step already credited them.
       const invokingUserActor = getAttributionKey(invokingUser);
-      if (invokingUserActor && !creditedActors.has(invokingUserActor)) {
+      if (user && invokingUserActor && !creditedActors.has(invokingUserActor)) {
         contributors.push({
           ...user,
           attribution: invokingUser
         });
         creditedActors.add(invokingUserActor);
       }
+
+      // The agent is always nameable, so it is credited even when its invoker is not — but
+      // without the connection, which would point at a contributor that was never created.
       contributors.push({
         ...agent,
         attribution: stepAttribution,
-        connectedTo: invokingUser
+        ...(user ? {
+          connectedTo: invokingUser
+        } : {})
       });
       creditedActors.add(actor);
       continue;
     }
     const user = userId ? resolveUser(userId, profilesByAccountId) : undefined;
     if (!user) {
-      return undefined;
+      // Unnamed, and a user has no generic fallback label, so this actor's changes go untagged.
+      continue;
     }
     contributors.push({
       ...user,

package/dist/esm/pm-plugins/resolveDiffContributors.js

@@ -64,8 +64,9 @@ var resolveAgent = function resolveAgent(attribution, profilesByAccountId) {
 
 /**
  * One contributor per distinct actor behind the attributed steps, resolved against the identities
- * the consumer supplied. Returns `undefined` if any actor cannot be named: a half-credited diff
- * reads as "nobody touched this", so the whole list is dropped and the plain diff renders instead.
+ * the consumer supplied. An actor the consumer cannot name is skipped rather than dropping the whole
+ * list: tags are per change, so its changes keep their diff colour and simply carry no tag, while
+ * the actors that *are* named stay credited. Returns `undefined` only when nothing resolves at all.
  */
 export var resolveDiffContributors = function resolveDiffContributors(stepsWithAttribution, profiles) {
   // Profiles opt callers into contributor tags; attribution alone still supplies diff colours.
@@ -104,28 +105,30 @@ export var resolveDiffContributors = function resolveDiffContributors(stepsWithA
           userId: userId
         };
         var _user = resolveUser(userId, profilesByAccountId);
-        if (!_user) {
-          return undefined;
-        }
 
         // Skipped if the invoking user's own step already credited them.
         var invokingUserActor = getAttributionKey(invokingUser);
-        if (invokingUserActor && !creditedActors.has(invokingUserActor)) {
+        if (_user && invokingUserActor && !creditedActors.has(invokingUserActor)) {
           contributors.push(_objectSpread(_objectSpread({}, _user), {}, {
             attribution: invokingUser
           }));
           creditedActors.add(invokingUserActor);
         }
+
+        // The agent is always nameable, so it is credited even when its invoker is not — but
+        // without the connection, which would point at a contributor that was never created.
         contributors.push(_objectSpread(_objectSpread({}, agent), {}, {
-          attribution: stepAttribution,
+          attribution: stepAttribution
+        }, _user ? {
           connectedTo: invokingUser
-        }));
+        } : {}));
         creditedActors.add(actor);
         continue;
       }
       var user = userId ? resolveUser(userId, profilesByAccountId) : undefined;
       if (!user) {
-        return undefined;
+        // Unnamed, and a user has no generic fallback label, so this actor's changes go untagged.
+        continue;
       }
       contributors.push(_objectSpread(_objectSpread({}, user), {}, {
         attribution: stepAttribution

package/dist/types/pm-plugins/resolveDiffContributors.d.ts

@@ -1,7 +1,8 @@
 import type { DiffContributorProfile, DiffContributors, StepWithAttribution } from '../showDiffPluginType';
 /**
  * One contributor per distinct actor behind the attributed steps, resolved against the identities
- * the consumer supplied. Returns `undefined` if any actor cannot be named: a half-credited diff
- * reads as "nobody touched this", so the whole list is dropped and the plain diff renders instead.
+ * the consumer supplied. An actor the consumer cannot name is skipped rather than dropping the whole
+ * list: tags are per change, so its changes keep their diff colour and simply carry no tag, while
+ * the actors that *are* named stay credited. Returns `undefined` only when nothing resolves at all.
  */
 export declare const resolveDiffContributors: <TStep>(stepsWithAttribution: Array<StepWithAttribution<TStep>>, profiles: readonly DiffContributorProfile[] | undefined) => DiffContributors | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "15.1.1",
+	"version": "15.1.2",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",