@atlaskit/react-ufo 3.6.0 → 3.6.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @atlaskit/ufo-interaction-ignore
 
+## 3.6.2
+
+### Patch Changes
+
+- [#143078](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/143078)
+  [`194c184c53045`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/194c184c53045) -
+  FF cleanup - platform-ufo-add-segment-use-effect and ufo_chr_config
+
+## 3.6.1
+
+### Patch Changes
+
+- [#142398](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/142398)
+  [`0f2c78fab5f90`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/0f2c78fab5f90) -
+  FF cleanup - platform_editor_ed-25937_ignore_mutations_for_ttvc
+- [#142273](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/142273)
+  [`21456ac374d24`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/21456ac374d24) -
+  AFO-3610 cleanup ff platform_ufo_vc_ignore_same_value_mutation
+
 ## 3.6.0
 
 ### Minor Changes

package/dist/cjs/segment/segment.js

@@ -82,10 +82,6 @@ function UFOSegment(_ref) {
   }, [parentContext, segmentName, segmentId]);
   var interactionId = (0, _react.useContext)(_interactionIdContext.default);
   var interactionContext = (0, _react.useMemo)(function () {
-    // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
-    if (!(0, _platformFeatureFlags.fg)('platform-ufo-add-segment-use-effect')) {
-      (0, _interactionMetrics.addSegment)(labelStack);
-    }
     var lastCompleteEndTime = 0;
     var complete = (0, _selfMeasurements.withProfiling)(function complete() {
       var endTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : performance.now();
@@ -274,9 +270,7 @@ function UFOSegment(_ref) {
     }
   }, [interactionContext]);
   (0, _react.useEffect)(function () {
-    if ((0, _platformFeatureFlags.fg)('platform-ufo-add-segment-use-effect')) {
-      (0, _interactionMetrics.addSegment)(labelStack);
-    }
+    (0, _interactionMetrics.addSegment)(labelStack);
     return function () {
       (0, _interactionMetrics.removeSegment)(labelStack);
     };

package/dist/cjs/vc/vc-observer/observers/index.js

@@ -33,12 +33,6 @@ var isElementVisible = (0, _selfMeasurements.withProfiling)(function isElementVi
   });
   return isVisible;
 }, ['vc']);
-var isInsideEditorContainer = (0, _selfMeasurements.withProfiling)(function isInsideEditorContainer(target) {
-  if (!target || typeof target.closest !== 'function') {
-    return false;
-  }
-  return Boolean(target.closest('.ProseMirror'));
-}, ['vc']);
 var Observers = exports.Observers = /*#__PURE__*/function () {
   function Observers(opts) {
     var _this = this;
@@ -248,31 +242,19 @@ var Observers = exports.Observers = /*#__PURE__*/function () {
             });
           } else if (mutation.type === 'attributes') {
             if (mutation.target instanceof HTMLElement) {
+              var _mutation$oldValue;
               var attributeName = mutation.attributeName;
-              if ((0, _platformFeatureFlags.fg)('platform_ufo_vc_ignore_same_value_mutation')) {
-                var _mutation$oldValue;
-                /*
-                	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
-                	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
-                	Conceptually there is after all a mutation: there is an old value replaced with a new one,
-                	and whether or not they are the same doesn't really matter.
-                	And Custom elements should work the same way as MutationObserver."
-                	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
-                */
-                var oldValue = (_mutation$oldValue = mutation.oldValue) !== null && _mutation$oldValue !== void 0 ? _mutation$oldValue : undefined;
-                var newValue = attributeName ? mutation.target.getAttribute(attributeName) : undefined;
-                if (oldValue !== newValue) {
-                  if ((0, _isNonVisualStyleMutation.default)(mutation)) {
-                    ignoreReason = 'non-visual-style';
-                  }
-                  if ((0, _platformFeatureFlags.fg)('platform_ufo_vc_fix_ignore_image_mutation')) {
-                    if ((0, _vcUtils.isContainedWithinMediaWrapper)(mutation.target)) {
-                      ignoreReason = 'image';
-                    }
-                  }
-                  _this2.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName, oldValue, newValue);
-                }
-              } else {
+              /*
+              	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
+              	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
+              	Conceptually there is after all a mutation: there is an old value replaced with a new one,
+              	and whether or not they are the same doesn't really matter.
+              	And Custom elements should work the same way as MutationObserver."
+              	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
+              */
+              var oldValue = (_mutation$oldValue = mutation.oldValue) !== null && _mutation$oldValue !== void 0 ? _mutation$oldValue : undefined;
+              var newValue = attributeName ? mutation.target.getAttribute(attributeName) : undefined;
+              if (oldValue !== newValue) {
                 if ((0, _isNonVisualStyleMutation.default)(mutation)) {
                   ignoreReason = 'non-visual-style';
                 }
@@ -281,7 +263,7 @@ var Observers = exports.Observers = /*#__PURE__*/function () {
                     ignoreReason = 'image';
                   }
                 }
-                _this2.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName);
+                _this2.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName, oldValue, newValue);
               }
             }
           }
@@ -345,11 +327,6 @@ var Observers = exports.Observers = /*#__PURE__*/function () {
             if (!isElementVisible(target)) {
               data.ignoreReason = 'not-visible';
             }
-            if ((0, _platformFeatureFlags.fg)('platform_editor_ed-25937_ignore_mutations_for_ttvc')) {
-              if (isInsideEditorContainer(target)) {
-                data.ignoreReason = 'editor-container-mutation';
-              }
-            }
             _this3.callbacks.forEach(function (callback) {
               var elementName;
               try {

package/dist/cjs/vc/vc-observer/revisions/fy25_01.js

@@ -15,7 +15,7 @@ var _selfMeasurements = require("../../../self-measurements");
 var _ViewportUpdateClassifier = require("./ViewportUpdateClassifier");
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-var legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view', 'editor-container-mutation'];
+var legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view'];
 var FY25_01Classifier = exports.FY25_01Classifier = /*#__PURE__*/function (_ViewportUpdateClassi) {
   function FY25_01Classifier() {
     var _this;

package/dist/cjs/vc/vc-observer-new/viewport-observer/mutation-observer/index.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _selfMeasurements = require("../../../../self-measurements");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
@@ -29,30 +28,22 @@ var createMutationObserver = (0, _selfMeasurements.withProfiling)(function creat
           continue;
         }
         if (mut.type === 'attributes') {
-          if ((0, _platformFeatureFlags.fg)('platform_ufo_vc_ignore_same_value_mutation')) {
-            var _mut$oldValue;
-            /*
-            "MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
-            I think it might have been something along the lines that for consistency every setAttribute call should create a record.
-            Conceptually there is after all a mutation: there is an old value replaced with a new one,
-            and whether or not they are the same doesn't really matter.
-            And Custom elements should work the same way as MutationObserver."
-            https://github.com/whatwg/dom/issues/520#issuecomment-336574796
-            */
-            var oldValue = (_mut$oldValue = mut.oldValue) !== null && _mut$oldValue !== void 0 ? _mut$oldValue : undefined;
-            var newValue = mut.attributeName ? mut.target.getAttribute(mut.attributeName) : undefined;
-            if (oldValue !== newValue) {
-              var _mut$attributeName;
-              onAttributeMutation({
-                target: mut.target,
-                attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
-              });
-            }
-          } else {
-            var _mut$attributeName2;
+          var _mut$oldValue;
+          /*
+          	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
+          	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
+          	Conceptually there is after all a mutation: there is an old value replaced with a new one,
+          	and whether or not they are the same doesn't really matter.
+          	And Custom elements should work the same way as MutationObserver."
+          	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
+          */
+          var oldValue = (_mut$oldValue = mut.oldValue) !== null && _mut$oldValue !== void 0 ? _mut$oldValue : undefined;
+          var newValue = mut.attributeName ? mut.target.getAttribute(mut.attributeName) : undefined;
+          if (oldValue !== newValue) {
+            var _mut$attributeName;
             onAttributeMutation({
               target: mut.target,
-              attributeName: (_mut$attributeName2 = mut.attributeName) !== null && _mut$attributeName2 !== void 0 ? _mut$attributeName2 : 'unknown'
+              attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
             });
           }
           continue;

package/dist/es2019/segment/segment.js

@@ -60,10 +60,6 @@ export default function UFOSegment({
   }], [parentContext, segmentName, segmentId]);
   const interactionId = useContext(UFOInteractionIDContext);
   const interactionContext = useMemo(() => {
-    // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
-    if (!fg('platform-ufo-add-segment-use-effect')) {
-      addSegment(labelStack);
-    }
     let lastCompleteEndTime = 0;
     const complete = withProfiling(function complete(endTime = performance.now()) {
       if (interactionId.current) {
@@ -247,9 +243,7 @@ export default function UFOSegment({
     }
   }, [interactionContext]);
   useEffect(() => {
-    if (fg('platform-ufo-add-segment-use-effect')) {
-      addSegment(labelStack);
-    }
+    addSegment(labelStack);
     return () => {
       removeSegment(labelStack);
     };

package/dist/es2019/vc/vc-observer/observers/index.js

@@ -22,12 +22,6 @@ const isElementVisible = withProfiling(function isElementVisible(target) {
   });
   return isVisible;
 }, ['vc']);
-const isInsideEditorContainer = withProfiling(function isInsideEditorContainer(target) {
-  if (!target || typeof target.closest !== 'function') {
-    return false;
-  }
-  return Boolean(target.closest('.ProseMirror'));
-}, ['vc']);
 export class Observers {
   constructor(opts) {
     _defineProperty(this, "observedMutations", new WeakMap());
@@ -218,31 +212,19 @@ export class Observers {
           });
         } else if (mutation.type === 'attributes') {
           if (mutation.target instanceof HTMLElement) {
+            var _mutation$oldValue;
             const attributeName = mutation.attributeName;
-            if (fg('platform_ufo_vc_ignore_same_value_mutation')) {
-              var _mutation$oldValue;
-              /*
-              	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
-              	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
-              	Conceptually there is after all a mutation: there is an old value replaced with a new one,
-              	and whether or not they are the same doesn't really matter.
-              	And Custom elements should work the same way as MutationObserver."
-              	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
-              */
-              const oldValue = (_mutation$oldValue = mutation.oldValue) !== null && _mutation$oldValue !== void 0 ? _mutation$oldValue : undefined;
-              const newValue = attributeName ? mutation.target.getAttribute(attributeName) : undefined;
-              if (oldValue !== newValue) {
-                if (isNonVisualStyleMutation(mutation)) {
-                  ignoreReason = 'non-visual-style';
-                }
-                if (fg('platform_ufo_vc_fix_ignore_image_mutation')) {
-                  if (isContainedWithinMediaWrapper(mutation.target)) {
-                    ignoreReason = 'image';
-                  }
-                }
-                this.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName, oldValue, newValue);
-              }
-            } else {
+            /*
+            	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
+            	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
+            	Conceptually there is after all a mutation: there is an old value replaced with a new one,
+            	and whether or not they are the same doesn't really matter.
+            	And Custom elements should work the same way as MutationObserver."
+            	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
+            */
+            const oldValue = (_mutation$oldValue = mutation.oldValue) !== null && _mutation$oldValue !== void 0 ? _mutation$oldValue : undefined;
+            const newValue = attributeName ? mutation.target.getAttribute(attributeName) : undefined;
+            if (oldValue !== newValue) {
               if (isNonVisualStyleMutation(mutation)) {
                 ignoreReason = 'non-visual-style';
               }
@@ -251,7 +233,7 @@ export class Observers {
                   ignoreReason = 'image';
                 }
               }
-              this.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName);
+              this.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName, oldValue, newValue);
             }
           }
         }
@@ -311,11 +293,6 @@ export class Observers {
           if (!isElementVisible(target)) {
             data.ignoreReason = 'not-visible';
           }
-          if (fg('platform_editor_ed-25937_ignore_mutations_for_ttvc')) {
-            if (isInsideEditorContainer(target)) {
-              data.ignoreReason = 'editor-container-mutation';
-            }
-          }
           this.callbacks.forEach(callback => {
             let elementName;
             try {

package/dist/es2019/vc/vc-observer/revisions/fy25_01.js

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { withProfiling } from '../../../self-measurements';
 import { ViewportUpdateClassifier } from './ViewportUpdateClassifier';
-const legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view', 'editor-container-mutation'];
+const legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view'];
 export class FY25_01Classifier extends ViewportUpdateClassifier {
   VCCalculationMethod({
     VCParts,

package/dist/es2019/vc/vc-observer-new/viewport-observer/mutation-observer/index.js

@@ -1,4 +1,3 @@
-import { fg } from '@atlaskit/platform-feature-flags';
 import { withProfiling } from '../../../../self-measurements';
 const createMutationObserver = withProfiling(function createMutationObserver(props) {
   if (!window || typeof window.IntersectionObserver !== 'function') {
@@ -16,30 +15,22 @@ const createMutationObserver = withProfiling(function createMutationObserver(pro
         continue;
       }
       if (mut.type === 'attributes') {
-        if (fg('platform_ufo_vc_ignore_same_value_mutation')) {
-          var _mut$oldValue;
-          /*
-          "MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
-          I think it might have been something along the lines that for consistency every setAttribute call should create a record.
-          Conceptually there is after all a mutation: there is an old value replaced with a new one,
-          and whether or not they are the same doesn't really matter.
-          And Custom elements should work the same way as MutationObserver."
-          https://github.com/whatwg/dom/issues/520#issuecomment-336574796
-          */
-          const oldValue = (_mut$oldValue = mut.oldValue) !== null && _mut$oldValue !== void 0 ? _mut$oldValue : undefined;
-          const newValue = mut.attributeName ? mut.target.getAttribute(mut.attributeName) : undefined;
-          if (oldValue !== newValue) {
-            var _mut$attributeName;
-            onAttributeMutation({
-              target: mut.target,
-              attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
-            });
-          }
-        } else {
-          var _mut$attributeName2;
+        var _mut$oldValue;
+        /*
+        	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
+        	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
+        	Conceptually there is after all a mutation: there is an old value replaced with a new one,
+        	and whether or not they are the same doesn't really matter.
+        	And Custom elements should work the same way as MutationObserver."
+        	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
+        */
+        const oldValue = (_mut$oldValue = mut.oldValue) !== null && _mut$oldValue !== void 0 ? _mut$oldValue : undefined;
+        const newValue = mut.attributeName ? mut.target.getAttribute(mut.attributeName) : undefined;
+        if (oldValue !== newValue) {
+          var _mut$attributeName;
           onAttributeMutation({
             target: mut.target,
-            attributeName: (_mut$attributeName2 = mut.attributeName) !== null && _mut$attributeName2 !== void 0 ? _mut$attributeName2 : 'unknown'
+            attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
           });
         }
         continue;

package/dist/esm/segment/segment.js

@@ -70,10 +70,6 @@ export default function UFOSegment(_ref) {
   }, [parentContext, segmentName, segmentId]);
   var interactionId = useContext(UFOInteractionIDContext);
   var interactionContext = useMemo(function () {
-    // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
-    if (!fg('platform-ufo-add-segment-use-effect')) {
-      addSegment(labelStack);
-    }
     var lastCompleteEndTime = 0;
     var complete = withProfiling(function complete() {
       var endTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : performance.now();
@@ -262,9 +258,7 @@ export default function UFOSegment(_ref) {
     }
   }, [interactionContext]);
   useEffect(function () {
-    if (fg('platform-ufo-add-segment-use-effect')) {
-      addSegment(labelStack);
-    }
+    addSegment(labelStack);
     return function () {
       removeSegment(labelStack);
     };

package/dist/esm/vc/vc-observer/observers/index.js

@@ -26,12 +26,6 @@ var isElementVisible = withProfiling(function isElementVisible(target) {
   });
   return isVisible;
 }, ['vc']);
-var isInsideEditorContainer = withProfiling(function isInsideEditorContainer(target) {
-  if (!target || typeof target.closest !== 'function') {
-    return false;
-  }
-  return Boolean(target.closest('.ProseMirror'));
-}, ['vc']);
 export var Observers = /*#__PURE__*/function () {
   function Observers(opts) {
     var _this = this;
@@ -241,31 +235,19 @@ export var Observers = /*#__PURE__*/function () {
             });
           } else if (mutation.type === 'attributes') {
             if (mutation.target instanceof HTMLElement) {
+              var _mutation$oldValue;
               var attributeName = mutation.attributeName;
-              if (fg('platform_ufo_vc_ignore_same_value_mutation')) {
-                var _mutation$oldValue;
-                /*
-                	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
-                	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
-                	Conceptually there is after all a mutation: there is an old value replaced with a new one,
-                	and whether or not they are the same doesn't really matter.
-                	And Custom elements should work the same way as MutationObserver."
-                	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
-                */
-                var oldValue = (_mutation$oldValue = mutation.oldValue) !== null && _mutation$oldValue !== void 0 ? _mutation$oldValue : undefined;
-                var newValue = attributeName ? mutation.target.getAttribute(attributeName) : undefined;
-                if (oldValue !== newValue) {
-                  if (isNonVisualStyleMutation(mutation)) {
-                    ignoreReason = 'non-visual-style';
-                  }
-                  if (fg('platform_ufo_vc_fix_ignore_image_mutation')) {
-                    if (isContainedWithinMediaWrapper(mutation.target)) {
-                      ignoreReason = 'image';
-                    }
-                  }
-                  _this2.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName, oldValue, newValue);
-                }
-              } else {
+              /*
+              	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
+              	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
+              	Conceptually there is after all a mutation: there is an old value replaced with a new one,
+              	and whether or not they are the same doesn't really matter.
+              	And Custom elements should work the same way as MutationObserver."
+              	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
+              */
+              var oldValue = (_mutation$oldValue = mutation.oldValue) !== null && _mutation$oldValue !== void 0 ? _mutation$oldValue : undefined;
+              var newValue = attributeName ? mutation.target.getAttribute(attributeName) : undefined;
+              if (oldValue !== newValue) {
                 if (isNonVisualStyleMutation(mutation)) {
                   ignoreReason = 'non-visual-style';
                 }
@@ -274,7 +256,7 @@ export var Observers = /*#__PURE__*/function () {
                     ignoreReason = 'image';
                   }
                 }
-                _this2.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName);
+                _this2.observeElement(mutation.target, mutation, 'attr', ignoreReason, attributeName, oldValue, newValue);
               }
             }
           }
@@ -338,11 +320,6 @@ export var Observers = /*#__PURE__*/function () {
             if (!isElementVisible(target)) {
               data.ignoreReason = 'not-visible';
             }
-            if (fg('platform_editor_ed-25937_ignore_mutations_for_ttvc')) {
-              if (isInsideEditorContainer(target)) {
-                data.ignoreReason = 'editor-container-mutation';
-              }
-            }
             _this3.callbacks.forEach(function (callback) {
               var elementName;
               try {

package/dist/esm/vc/vc-observer/revisions/fy25_01.js

@@ -8,7 +8,7 @@ function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstruct
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 import { withProfiling } from '../../../self-measurements';
 import { ViewportUpdateClassifier } from './ViewportUpdateClassifier';
-var legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view', 'editor-container-mutation'];
+var legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view'];
 export var FY25_01Classifier = /*#__PURE__*/function (_ViewportUpdateClassi) {
   function FY25_01Classifier() {
     var _this;

package/dist/esm/vc/vc-observer-new/viewport-observer/mutation-observer/index.js

@@ -1,7 +1,6 @@
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-import { fg } from '@atlaskit/platform-feature-flags';
 import { withProfiling } from '../../../../self-measurements';
 var createMutationObserver = withProfiling(function createMutationObserver(props) {
   if (!window || typeof window.IntersectionObserver !== 'function') {
@@ -23,30 +22,22 @@ var createMutationObserver = withProfiling(function createMutationObserver(props
           continue;
         }
         if (mut.type === 'attributes') {
-          if (fg('platform_ufo_vc_ignore_same_value_mutation')) {
-            var _mut$oldValue;
-            /*
-            "MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
-            I think it might have been something along the lines that for consistency every setAttribute call should create a record.
-            Conceptually there is after all a mutation: there is an old value replaced with a new one,
-            and whether or not they are the same doesn't really matter.
-            And Custom elements should work the same way as MutationObserver."
-            https://github.com/whatwg/dom/issues/520#issuecomment-336574796
-            */
-            var oldValue = (_mut$oldValue = mut.oldValue) !== null && _mut$oldValue !== void 0 ? _mut$oldValue : undefined;
-            var newValue = mut.attributeName ? mut.target.getAttribute(mut.attributeName) : undefined;
-            if (oldValue !== newValue) {
-              var _mut$attributeName;
-              onAttributeMutation({
-                target: mut.target,
-                attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
-              });
-            }
-          } else {
-            var _mut$attributeName2;
+          var _mut$oldValue;
+          /*
+          	"MutationObserver was explicitly designed to work that way, but I can't now recall the reasoning.
+          	I think it might have been something along the lines that for consistency every setAttribute call should create a record.
+          	Conceptually there is after all a mutation: there is an old value replaced with a new one,
+          	and whether or not they are the same doesn't really matter.
+          	And Custom elements should work the same way as MutationObserver."
+          	https://github.com/whatwg/dom/issues/520#issuecomment-336574796
+          */
+          var oldValue = (_mut$oldValue = mut.oldValue) !== null && _mut$oldValue !== void 0 ? _mut$oldValue : undefined;
+          var newValue = mut.attributeName ? mut.target.getAttribute(mut.attributeName) : undefined;
+          if (oldValue !== newValue) {
+            var _mut$attributeName;
             onAttributeMutation({
               target: mut.target,
-              attributeName: (_mut$attributeName2 = mut.attributeName) !== null && _mut$attributeName2 !== void 0 ? _mut$attributeName2 : 'unknown'
+              attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
             });
           }
           continue;

package/dist/types/common/vc/types.d.ts

@@ -37,7 +37,7 @@ export type VCEntryType = {
     vc: number;
     elements: string[];
 };
-export type VCIgnoreReason = 'image' | 'ssr-hydration' | 'editor-lazy-node-view' | 'not-visible' | 'editor-container-mutation' | 'non-visual-style' | '';
+export type VCIgnoreReason = 'image' | 'ssr-hydration' | 'editor-lazy-node-view' | 'not-visible' | 'non-visual-style' | '';
 export type ComponentsLogEntry = {
     type?: string;
     targetName: string;

package/dist/types-ts4.5/common/vc/types.d.ts

@@ -37,7 +37,7 @@ export type VCEntryType = {
     vc: number;
     elements: string[];
 };
-export type VCIgnoreReason = 'image' | 'ssr-hydration' | 'editor-lazy-node-view' | 'not-visible' | 'editor-container-mutation' | 'non-visual-style' | '';
+export type VCIgnoreReason = 'image' | 'ssr-hydration' | 'editor-lazy-node-view' | 'not-visible' | 'non-visual-style' | '';
 export type ComponentsLogEntry = {
     type?: string;
     targetName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/react-ufo",
-	"version": "3.6.0",
+	"version": "3.6.2",
 	"description": "Parts of React UFO that are publicly available",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -130,9 +130,6 @@
 		"platform_ufo_canvas_heatmap_full_precision": {
 			"type": "boolean"
 		},
-		"platform_editor_ed-25937_ignore_mutations_for_ttvc": {
-			"type": "boolean"
-		},
 		"enable-react-ufo-payload-segment-compressed": {
 			"type": "boolean"
 		},
@@ -142,12 +139,6 @@
 		"ufo-calc-speed-index": {
 			"type": "boolean"
 		},
-		"platform-ufo-add-segment-use-effect": {
-			"type": "boolean"
-		},
-		"ufo_chr_config": {
-			"type": "boolean"
-		},
 		"ufo_support_other_resource_type_js": {
 			"type": "boolean"
 		},
@@ -172,9 +163,6 @@
 		"ufo_payload_use_idle_callback": {
 			"type": "boolean"
 		},
-		"platform_ufo_vc_ignore_same_value_mutation": {
-			"type": "boolean"
-		},
 		"platform_ufo_disable_ttvc_v1": {
 			"type": "boolean"
 		},