@atlaskit/adf-schema 40.8.2 → 40.9.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/adf-schema
 
+## 40.9.0
+
+### Minor Changes
+
+- dcc54e6: [ED-24636] Implements BatchAttrsStep
+
 ## 40.8.2
 
 ### Patch Changes

package/dist/cjs/steps/batch-attrs-step.js

@@ -0,0 +1,191 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BatchAttrsStep = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 stepType = 'batchAttrs';
+var isValidData = function isValidData(data) {
+  if (data !== null && !Array.isArray(data)) {
+    return false;
+  }
+  return !data.some(function (d) {
+    var invalidPosition = typeof d.position !== 'number';
+    var invalidNodeType = typeof d.nodeType !== 'string';
+    var invalidAttrs = (0, _typeof2.default)(d.attrs) !== 'object';
+    return invalidPosition || invalidNodeType || invalidAttrs;
+  });
+};
+
+/**
+ * 📢 Public API: Editor FE Platform
+ *
+ * Represents a step that applies a batch of attribute changes to nodes in a ProseMirror document.
+ *
+ * This step is particularly useful when you need to update the attributes of multiple nodes in a document
+ * in a single operation. For example, you might want to change the color of several panels or update metadata
+ * for various sections without needing to perform multiple separate operations.
+ *
+ * **Use Cases:**
+ * - **Efficiency**: Apply multiple attribute changes in a single step to reduce the number of operations.
+ * - **Atomicity**: Ensure that a group of attribute changes are applied together, maintaining document consistency.
+ * - **Consistency**: Use when changes are logically related, such as updating theme attributes for a document section.
+ *
+ * **When Not to Use:**
+ * - **Single Changes**: If you only need to change attributes on a single node, a more straightforward step might be suitable like `AttrsStep` from prosemirror.
+ * - **Complex Node Transformations**: This step is designed for attribute changes rather than structural changes.
+ * - **Performance Concerns**: While efficient for batch updates, unnecessary use for single updates may add overhead.
+ *
+ * @example
+ * ```typescript
+ * import { BatchAttrsStep } from '@atlaskit/adf-schema/steps';
+ *
+ * // Define the attribute changes
+ * const changes = [
+ *   {
+ *     position: 0, // Position of the first panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'error' }
+ *   },
+ *   {
+ *     position: 7, // Position of the second panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'success' }
+ *   }
+ * ];
+ *
+ * // Create the step and apply it to the document
+ * const step = new BatchAttrsStep(changes);
+ *
+ * const tr = editorState.tr;
+ *
+ * tr.step(step);
+ * ```
+ *
+ * @class
+ * @extends {Step}
+ */
+var BatchAttrsStep = exports.BatchAttrsStep = /*#__PURE__*/function (_Step) {
+  function BatchAttrsStep(data) {
+    var _this;
+    var inverted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    (0, _classCallCheck2.default)(this, BatchAttrsStep);
+    _this = _callSuper(this, BatchAttrsStep);
+    _this.data = data;
+    _this.inverted = inverted;
+    return _this;
+  }
+  (0, _inherits2.default)(BatchAttrsStep, _Step);
+  return (0, _createClass2.default)(BatchAttrsStep, [{
+    key: "apply",
+    value: function apply(doc) {
+      var resultDoc = this.data.reduce(function (acc, value) {
+        var _acc$doc;
+        if (!acc.doc || acc.failed) {
+          return acc;
+        }
+        var position = value.position,
+          attrs = value.attrs;
+        if (acc.doc && position > acc.doc.nodeSize || position < 0) {
+          return _transform.StepResult.fail("Position ".concat(position, " out of document range."));
+        }
+        var target = (_acc$doc = acc.doc) === null || _acc$doc === void 0 ? void 0 : _acc$doc.nodeAt(position);
+        if (!target) {
+          return _transform.StepResult.fail("No node at given position: ".concat(position));
+        }
+        if (target.isText) {
+          return _transform.StepResult.fail('Target is a text node. Attributes are not allowed.');
+        }
+        var mergedAttrs = _objectSpread(_objectSpread({}, target.attrs || {}), attrs || {});
+        var updatedNode = target.type.create(mergedAttrs, null, target.marks);
+        var slice = new _model.Slice(_model.Fragment.from(updatedNode), 0, target.isLeaf ? 0 : 1);
+        return _transform.StepResult.fromReplace(acc.doc, position, position + 1, slice);
+      }, _transform.StepResult.ok(doc));
+      return resultDoc;
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      var previousData = this.data.reduce(function (acc, value) {
+        var position = value.position,
+          nodeType = value.nodeType,
+          nextAttrs = value.attrs;
+        if (position > doc.nodeSize) {
+          return acc;
+        }
+        var target = doc.nodeAt(position);
+        if (!target) {
+          return acc;
+        }
+        if (target.isText) {
+          return acc;
+        }
+        var previousAttrs = Object.keys(nextAttrs).reduce(function (attributesIterator, key) {
+          var oldValue = target.attrs[key];
+          attributesIterator[key] = oldValue;
+          return attributesIterator;
+        }, {});
+        var prev = {
+          position: position,
+          nodeType: nodeType,
+          attrs: previousAttrs
+        };
+        acc.push(prev);
+        return acc;
+      }, []);
+      return new BatchAttrsStep(previousData, true);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var mappedData = this.data.reduce(function (acc, value) {
+        var position = value.position;
+        var mappedPosition = mapping.mapResult(position);
+        if (mappedPosition.deleted) {
+          return acc;
+        }
+        acc.push(_objectSpread(_objectSpread({}, value), {}, {
+          position: mappedPosition.pos
+        }));
+        return acc;
+      }, []);
+      if (mappedData.length === 0) {
+        return null;
+      }
+      return new BatchAttrsStep(mappedData, this.inverted);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        stepType: stepType,
+        data: this.data,
+        inverted: this.inverted
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function fromJSON(_schema, json) {
+      var data = json === null || json === void 0 ? void 0 : json.data;
+      if (!isValidData(data)) {
+        throw new Error('Invalid input for BatchAttrsStep.fromJSON');
+      }
+      return new BatchAttrsStep(data, Boolean(json.inverted));
+    }
+  }]);
+}(_transform.Step);
+_transform.Step.jsonID(stepType, BatchAttrsStep);

package/dist/cjs/steps.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "AnalyticsStep", {
     return _analytics.AnalyticsStep;
   }
 });
+Object.defineProperty(exports, "BatchAttrsStep", {
+  enumerable: true,
+  get: function get() {
+    return _batchAttrsStep.BatchAttrsStep;
+  }
+});
 Object.defineProperty(exports, "InsertTypeAheadStages", {
   enumerable: true,
   get: function get() {
@@ -43,4 +49,5 @@ var _typeAhead = require("./steps/type-ahead");
 var _setAttrs = require("./steps/set-attrs");
 var _analytics = require("./steps/analytics");
 var _linkMetaStep = require("./steps/link-meta-step");
-var _overrideDocumentStep = require("./steps/override-document-step");
+var _overrideDocumentStep = require("./steps/override-document-step");
+var _batchAttrsStep = require("./steps/batch-attrs-step");

package/dist/es2019/steps/batch-attrs-step.js

@@ -0,0 +1,167 @@
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { Step, StepResult } from '@atlaskit/editor-prosemirror/transform';
+const stepType = 'batchAttrs';
+const isValidData = data => {
+  if (data !== null && !Array.isArray(data)) {
+    return false;
+  }
+  return !data.some(d => {
+    const invalidPosition = typeof d.position !== 'number';
+    const invalidNodeType = typeof d.nodeType !== 'string';
+    const invalidAttrs = typeof d.attrs !== 'object';
+    return invalidPosition || invalidNodeType || invalidAttrs;
+  });
+};
+
+/**
+ * 📢 Public API: Editor FE Platform
+ *
+ * Represents a step that applies a batch of attribute changes to nodes in a ProseMirror document.
+ *
+ * This step is particularly useful when you need to update the attributes of multiple nodes in a document
+ * in a single operation. For example, you might want to change the color of several panels or update metadata
+ * for various sections without needing to perform multiple separate operations.
+ *
+ * **Use Cases:**
+ * - **Efficiency**: Apply multiple attribute changes in a single step to reduce the number of operations.
+ * - **Atomicity**: Ensure that a group of attribute changes are applied together, maintaining document consistency.
+ * - **Consistency**: Use when changes are logically related, such as updating theme attributes for a document section.
+ *
+ * **When Not to Use:**
+ * - **Single Changes**: If you only need to change attributes on a single node, a more straightforward step might be suitable like `AttrsStep` from prosemirror.
+ * - **Complex Node Transformations**: This step is designed for attribute changes rather than structural changes.
+ * - **Performance Concerns**: While efficient for batch updates, unnecessary use for single updates may add overhead.
+ *
+ * @example
+ * ```typescript
+ * import { BatchAttrsStep } from '@atlaskit/adf-schema/steps';
+ *
+ * // Define the attribute changes
+ * const changes = [
+ *   {
+ *     position: 0, // Position of the first panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'error' }
+ *   },
+ *   {
+ *     position: 7, // Position of the second panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'success' }
+ *   }
+ * ];
+ *
+ * // Create the step and apply it to the document
+ * const step = new BatchAttrsStep(changes);
+ *
+ * const tr = editorState.tr;
+ *
+ * tr.step(step);
+ * ```
+ *
+ * @class
+ * @extends {Step}
+ */
+export class BatchAttrsStep extends Step {
+  constructor(data, inverted = false) {
+    super();
+    this.data = data;
+    this.inverted = inverted;
+  }
+  apply(doc) {
+    const resultDoc = this.data.reduce((acc, value) => {
+      var _acc$doc;
+      if (!acc.doc || acc.failed) {
+        return acc;
+      }
+      const {
+        position,
+        attrs
+      } = value;
+      if (acc.doc && position > acc.doc.nodeSize || position < 0) {
+        return StepResult.fail(`Position ${position} out of document range.`);
+      }
+      const target = (_acc$doc = acc.doc) === null || _acc$doc === void 0 ? void 0 : _acc$doc.nodeAt(position);
+      if (!target) {
+        return StepResult.fail(`No node at given position: ${position}`);
+      }
+      if (target.isText) {
+        return StepResult.fail('Target is a text node. Attributes are not allowed.');
+      }
+      const mergedAttrs = {
+        ...(target.attrs || {}),
+        ...(attrs || {})
+      };
+      const updatedNode = target.type.create(mergedAttrs, null, target.marks);
+      const slice = new Slice(Fragment.from(updatedNode), 0, target.isLeaf ? 0 : 1);
+      return StepResult.fromReplace(acc.doc, position, position + 1, slice);
+    }, StepResult.ok(doc));
+    return resultDoc;
+  }
+  invert(doc) {
+    const previousData = this.data.reduce((acc, value) => {
+      const {
+        position,
+        nodeType,
+        attrs: nextAttrs
+      } = value;
+      if (position > doc.nodeSize) {
+        return acc;
+      }
+      const target = doc.nodeAt(position);
+      if (!target) {
+        return acc;
+      }
+      if (target.isText) {
+        return acc;
+      }
+      const previousAttrs = Object.keys(nextAttrs).reduce((attributesIterator, key) => {
+        const oldValue = target.attrs[key];
+        attributesIterator[key] = oldValue;
+        return attributesIterator;
+      }, {});
+      const prev = {
+        position,
+        nodeType,
+        attrs: previousAttrs
+      };
+      acc.push(prev);
+      return acc;
+    }, []);
+    return new BatchAttrsStep(previousData, true);
+  }
+  map(mapping) {
+    const mappedData = this.data.reduce((acc, value) => {
+      const {
+        position
+      } = value;
+      const mappedPosition = mapping.mapResult(position);
+      if (mappedPosition.deleted) {
+        return acc;
+      }
+      acc.push({
+        ...value,
+        position: mappedPosition.pos
+      });
+      return acc;
+    }, []);
+    if (mappedData.length === 0) {
+      return null;
+    }
+    return new BatchAttrsStep(mappedData, this.inverted);
+  }
+  toJSON() {
+    return {
+      stepType,
+      data: this.data,
+      inverted: this.inverted
+    };
+  }
+  static fromJSON(_schema, json) {
+    const data = json === null || json === void 0 ? void 0 : json.data;
+    if (!isValidData(data)) {
+      throw new Error('Invalid input for BatchAttrsStep.fromJSON');
+    }
+    return new BatchAttrsStep(data, Boolean(json.inverted));
+  }
+}
+Step.jsonID(stepType, BatchAttrsStep);

package/dist/es2019/steps.js

@@ -2,4 +2,5 @@ export { InsertTypeAheadStages, InsertTypeAheadStep } from './steps/type-ahead';
 export { SetAttrsStep } from './steps/set-attrs';
 export { AnalyticsStep } from './steps/analytics';
 export { LinkMetaStep } from './steps/link-meta-step';
-export { OverrideDocumentStep } from './steps/override-document-step';
+export { OverrideDocumentStep } from './steps/override-document-step';
+export { BatchAttrsStep } from './steps/batch-attrs-step';

package/dist/esm/steps/batch-attrs-step.js

@@ -0,0 +1,184 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _typeof from "@babel/runtime/helpers/typeof";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(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; })(); }
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { Step, StepResult } from '@atlaskit/editor-prosemirror/transform';
+var stepType = 'batchAttrs';
+var isValidData = function isValidData(data) {
+  if (data !== null && !Array.isArray(data)) {
+    return false;
+  }
+  return !data.some(function (d) {
+    var invalidPosition = typeof d.position !== 'number';
+    var invalidNodeType = typeof d.nodeType !== 'string';
+    var invalidAttrs = _typeof(d.attrs) !== 'object';
+    return invalidPosition || invalidNodeType || invalidAttrs;
+  });
+};
+
+/**
+ * 📢 Public API: Editor FE Platform
+ *
+ * Represents a step that applies a batch of attribute changes to nodes in a ProseMirror document.
+ *
+ * This step is particularly useful when you need to update the attributes of multiple nodes in a document
+ * in a single operation. For example, you might want to change the color of several panels or update metadata
+ * for various sections without needing to perform multiple separate operations.
+ *
+ * **Use Cases:**
+ * - **Efficiency**: Apply multiple attribute changes in a single step to reduce the number of operations.
+ * - **Atomicity**: Ensure that a group of attribute changes are applied together, maintaining document consistency.
+ * - **Consistency**: Use when changes are logically related, such as updating theme attributes for a document section.
+ *
+ * **When Not to Use:**
+ * - **Single Changes**: If you only need to change attributes on a single node, a more straightforward step might be suitable like `AttrsStep` from prosemirror.
+ * - **Complex Node Transformations**: This step is designed for attribute changes rather than structural changes.
+ * - **Performance Concerns**: While efficient for batch updates, unnecessary use for single updates may add overhead.
+ *
+ * @example
+ * ```typescript
+ * import { BatchAttrsStep } from '@atlaskit/adf-schema/steps';
+ *
+ * // Define the attribute changes
+ * const changes = [
+ *   {
+ *     position: 0, // Position of the first panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'error' }
+ *   },
+ *   {
+ *     position: 7, // Position of the second panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'success' }
+ *   }
+ * ];
+ *
+ * // Create the step and apply it to the document
+ * const step = new BatchAttrsStep(changes);
+ *
+ * const tr = editorState.tr;
+ *
+ * tr.step(step);
+ * ```
+ *
+ * @class
+ * @extends {Step}
+ */
+export var BatchAttrsStep = /*#__PURE__*/function (_Step) {
+  function BatchAttrsStep(data) {
+    var _this;
+    var inverted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, BatchAttrsStep);
+    _this = _callSuper(this, BatchAttrsStep);
+    _this.data = data;
+    _this.inverted = inverted;
+    return _this;
+  }
+  _inherits(BatchAttrsStep, _Step);
+  return _createClass(BatchAttrsStep, [{
+    key: "apply",
+    value: function apply(doc) {
+      var resultDoc = this.data.reduce(function (acc, value) {
+        var _acc$doc;
+        if (!acc.doc || acc.failed) {
+          return acc;
+        }
+        var position = value.position,
+          attrs = value.attrs;
+        if (acc.doc && position > acc.doc.nodeSize || position < 0) {
+          return StepResult.fail("Position ".concat(position, " out of document range."));
+        }
+        var target = (_acc$doc = acc.doc) === null || _acc$doc === void 0 ? void 0 : _acc$doc.nodeAt(position);
+        if (!target) {
+          return StepResult.fail("No node at given position: ".concat(position));
+        }
+        if (target.isText) {
+          return StepResult.fail('Target is a text node. Attributes are not allowed.');
+        }
+        var mergedAttrs = _objectSpread(_objectSpread({}, target.attrs || {}), attrs || {});
+        var updatedNode = target.type.create(mergedAttrs, null, target.marks);
+        var slice = new Slice(Fragment.from(updatedNode), 0, target.isLeaf ? 0 : 1);
+        return StepResult.fromReplace(acc.doc, position, position + 1, slice);
+      }, StepResult.ok(doc));
+      return resultDoc;
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      var previousData = this.data.reduce(function (acc, value) {
+        var position = value.position,
+          nodeType = value.nodeType,
+          nextAttrs = value.attrs;
+        if (position > doc.nodeSize) {
+          return acc;
+        }
+        var target = doc.nodeAt(position);
+        if (!target) {
+          return acc;
+        }
+        if (target.isText) {
+          return acc;
+        }
+        var previousAttrs = Object.keys(nextAttrs).reduce(function (attributesIterator, key) {
+          var oldValue = target.attrs[key];
+          attributesIterator[key] = oldValue;
+          return attributesIterator;
+        }, {});
+        var prev = {
+          position: position,
+          nodeType: nodeType,
+          attrs: previousAttrs
+        };
+        acc.push(prev);
+        return acc;
+      }, []);
+      return new BatchAttrsStep(previousData, true);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var mappedData = this.data.reduce(function (acc, value) {
+        var position = value.position;
+        var mappedPosition = mapping.mapResult(position);
+        if (mappedPosition.deleted) {
+          return acc;
+        }
+        acc.push(_objectSpread(_objectSpread({}, value), {}, {
+          position: mappedPosition.pos
+        }));
+        return acc;
+      }, []);
+      if (mappedData.length === 0) {
+        return null;
+      }
+      return new BatchAttrsStep(mappedData, this.inverted);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        stepType: stepType,
+        data: this.data,
+        inverted: this.inverted
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function fromJSON(_schema, json) {
+      var data = json === null || json === void 0 ? void 0 : json.data;
+      if (!isValidData(data)) {
+        throw new Error('Invalid input for BatchAttrsStep.fromJSON');
+      }
+      return new BatchAttrsStep(data, Boolean(json.inverted));
+    }
+  }]);
+}(Step);
+Step.jsonID(stepType, BatchAttrsStep);

package/dist/esm/steps.js

@@ -2,4 +2,5 @@ export { InsertTypeAheadStages, InsertTypeAheadStep } from './steps/type-ahead';
 export { SetAttrsStep } from './steps/set-attrs';
 export { AnalyticsStep } from './steps/analytics';
 export { LinkMetaStep } from './steps/link-meta-step';
-export { OverrideDocumentStep } from './steps/override-document-step';
+export { OverrideDocumentStep } from './steps/override-document-step';
+export { BatchAttrsStep } from './steps/batch-attrs-step';

package/dist/types/steps/batch-attrs-step.d.ts

@@ -0,0 +1,74 @@
+import { type Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Step, StepResult } from '@atlaskit/editor-prosemirror/transform';
+import type { Mappable } from '@atlaskit/editor-prosemirror/transform';
+export type BatchAttrsStepData = {
+    position: number;
+    nodeType: string;
+    attrs: Record<string, unknown>;
+};
+/**
+ * 📢 Public API: Editor FE Platform
+ *
+ * Represents a step that applies a batch of attribute changes to nodes in a ProseMirror document.
+ *
+ * This step is particularly useful when you need to update the attributes of multiple nodes in a document
+ * in a single operation. For example, you might want to change the color of several panels or update metadata
+ * for various sections without needing to perform multiple separate operations.
+ *
+ * **Use Cases:**
+ * - **Efficiency**: Apply multiple attribute changes in a single step to reduce the number of operations.
+ * - **Atomicity**: Ensure that a group of attribute changes are applied together, maintaining document consistency.
+ * - **Consistency**: Use when changes are logically related, such as updating theme attributes for a document section.
+ *
+ * **When Not to Use:**
+ * - **Single Changes**: If you only need to change attributes on a single node, a more straightforward step might be suitable like `AttrsStep` from prosemirror.
+ * - **Complex Node Transformations**: This step is designed for attribute changes rather than structural changes.
+ * - **Performance Concerns**: While efficient for batch updates, unnecessary use for single updates may add overhead.
+ *
+ * @example
+ * ```typescript
+ * import { BatchAttrsStep } from '@atlaskit/adf-schema/steps';
+ *
+ * // Define the attribute changes
+ * const changes = [
+ *   {
+ *     position: 0, // Position of the first panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'error' }
+ *   },
+ *   {
+ *     position: 7, // Position of the second panel
+ *     nodeType: 'panel',
+ *     attrs: { panelType: 'success' }
+ *   }
+ * ];
+ *
+ * // Create the step and apply it to the document
+ * const step = new BatchAttrsStep(changes);
+ *
+ * const tr = editorState.tr;
+ *
+ * tr.step(step);
+ * ```
+ *
+ * @class
+ * @extends {Step}
+ */
+export declare class BatchAttrsStep extends Step {
+    data: Array<BatchAttrsStepData>;
+    private inverted;
+    constructor(data: Array<BatchAttrsStepData>, inverted?: boolean);
+    apply(doc: PMNode): StepResult;
+    invert(doc: PMNode): BatchAttrsStep;
+    map(mapping: Mappable): BatchAttrsStep;
+    toJSON(): {
+        stepType: string;
+        data: BatchAttrsStepData[];
+        inverted: boolean;
+    };
+    static fromJSON(_schema: Schema, json: {
+        data: Array<Record<string, unknown>>;
+        inverted?: boolean;
+    }): BatchAttrsStep;
+}

package/dist/types/steps.d.ts

@@ -6,3 +6,5 @@ export { LinkMetaStep } from './steps/link-meta-step';
 export type { LinkStepMetadata } from './steps/link-meta-step';
 export { OverrideDocumentStep } from './steps/override-document-step';
 export type { OverrideDocumentStepJSON } from './steps/override-document-step';
+export { BatchAttrsStep } from './steps/batch-attrs-step';
+export type { BatchAttrsStepData } from './steps/batch-attrs-step';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/adf-schema",
-  "version": "40.8.2",
+  "version": "40.9.0",
   "description": "Shared package that contains the ADF-schema (json) and ProseMirror node/mark specs",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"