@atlaskit/editor-plugin-block-menu 5.1.11 → 5.2.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 5.2.1
+
+### Patch Changes
+
+- [`e1a0f13fc5c83`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/e1a0f13fc5c83) -
+  Editor-2778: Table transform to expand and layout
+- Updated dependencies
+
+## 5.2.0
+
+### Minor Changes
+
+- [`0bff72d37394d`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/0bff72d37394d) -
+  [ux] Implement steps for bullet, task, and numbered lists transformations to container nodes
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 5.1.11
 
 ### Patch Changes

package/dist/cjs/editor-commands/transform-node-utils/steps/convertBulletListToTextStep.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertBulletListToTextStep = void 0;
+var _createListToTextStep = require("./createListToTextStep");
+/**
+ * Given an array of nodes, processes each bullet list by converting its items
+ * to paragraphs with "- " prefix.
+ *
+ * Handles nested bullet lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - bulletList()(
+ *     listItem()(p()('Item 1')),
+ *     bulletList()(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('- Item 1')
+ * - p()('   - Sub item 1')
+ */
+var convertBulletListToTextStep = exports.convertBulletListToTextStep = (0, _createListToTextStep.createListToTextStep)({
+  listTypeName: 'bulletList',
+  itemTypeName: 'listItem',
+  indent: '   ',
+  // 3 spaces per nesting level
+  getPrefix: function getPrefix() {
+    return '- ';
+  },
+  unwrapParagraphContent: true
+});

package/dist/cjs/editor-commands/transform-node-utils/steps/convertOrderedListToTextStep.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertOrderedListToTextStep = void 0;
+var _createListToTextStep = require("./createListToTextStep");
+/**
+ * Converts a number to a letter (1=a, 2=b, etc.)
+ * For numbers > 26, continues with aa, ab, etc.
+ */
+var numberToLetter = function numberToLetter(num) {
+  var result = '';
+  var n = num;
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(97 + n % 26) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+};
+
+/**
+ * Gets the appropriate prefix for an ordered list item based on depth and index.
+ * - Level 0: "1. ", "2. ", "3. ", etc.
+ * - Level 1+: "a. ", "b. ", "c. ", etc.
+ */
+var getOrderedListPrefix = function getOrderedListPrefix(depth, index) {
+  if (depth === 0) {
+    return "".concat(index, ". ");
+  }
+  return "".concat(numberToLetter(index), ". ");
+};
+
+/**
+ * Given an array of nodes, processes each ordered list by converting its items
+ * to paragraphs with numbered prefixes (1., 2., 3.) at the top level and
+ * lettered prefixes (a., b., c.) for nested levels.
+ *
+ * Handles nested ordered lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - orderedList({ order: 1 })(
+ *     listItem()(p()('Item 1')),
+ *     orderedList({ order: 1 })(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('1. Item 1')
+ * - p()('   a. Sub item 1')
+ */
+var convertOrderedListToTextStep = exports.convertOrderedListToTextStep = (0, _createListToTextStep.createListToTextStep)({
+  listTypeName: 'orderedList',
+  itemTypeName: 'listItem',
+  indent: '   ',
+  // 3 spaces per nesting level
+  getPrefix: function getPrefix(depth, index) {
+    return getOrderedListPrefix(depth, index);
+  },
+  unwrapParagraphContent: true
+});

package/dist/cjs/editor-commands/transform-node-utils/steps/convertTaskListToTextStep.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertTaskListToTextStep = void 0;
+var _createListToTextStep = require("./createListToTextStep");
+/**
+ * Given an array of nodes, processes each task list by converting its items
+ * to paragraphs with a checkbox prefix. Uses "[] " for unchecked (TODO) tasks
+ * and "[x] " for checked (DONE) tasks.
+ *
+ * Handles nested task lists recursively with 4-space indentation per level.
+ *
+ * This is used when converting a task list to a container that doesn't support
+ * task items (like blockquote).
+ *
+ * @example
+ * Input:
+ * - taskList()(
+ *     taskItem({ state: 'TODO' })('Task list item'),
+ *     taskList()(taskItem({ state: 'DONE' })('Nested done task'))
+ *   )
+ *
+ * Output:
+ * - p()('[] Task list item')
+ * - p()('    [x] Nested done task')
+ */
+var convertTaskListToTextStep = exports.convertTaskListToTextStep = (0, _createListToTextStep.createListToTextStep)({
+  listTypeName: 'taskList',
+  itemTypeName: 'taskItem',
+  indent: '    ',
+  // 4 spaces per nesting level
+  getPrefix: function getPrefix(_, __, itemNode) {
+    var _itemNode$attrs;
+    return ((_itemNode$attrs = itemNode.attrs) === null || _itemNode$attrs === void 0 ? void 0 : _itemNode$attrs.state) === 'DONE' ? '[x] ' : '[] ';
+  },
+  unwrapParagraphContent: false
+});

package/dist/cjs/editor-commands/transform-node-utils/steps/createListToTextStep.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createListToTextStep = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
+/**
+ * Configuration for creating a list-to-text transformation step.
+ */
+
+/**
+ * Recursively extracts list items from a list (including nested lists)
+ * and converts them to paragraphs with configurable prefixes and indentation.
+ */
+var extractListItemsAsParagraphs = function extractListItemsAsParagraphs(node, schema, config) {
+  var paragraphs = [];
+  var paragraphType = schema.nodes.paragraph;
+  var listType = schema.nodes[config.listTypeName];
+  var itemType = schema.nodes[config.itemTypeName];
+  var _extract = function extract(currentNode) {
+    var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var itemIndex = 0;
+    currentNode.forEach(function (child) {
+      if (child.type === itemType) {
+        itemIndex++;
+        var indent = config.indent.repeat(depth);
+        var prefix = config.getPrefix(depth, itemIndex, child);
+        var listPrefix = schema.text("".concat(indent).concat(prefix));
+
+        // Collect inline content and nested lists separately
+        var inlineContent = [];
+        var nestedLists = [];
+        child.forEach(function (grandChild) {
+          if (grandChild.type === listType) {
+            nestedLists.push(grandChild);
+          } else if (config.unwrapParagraphContent && grandChild.type === paragraphType) {
+            // Extract content from paragraph nodes
+            grandChild.forEach(function (content) {
+              inlineContent.push(content);
+            });
+          } else {
+            inlineContent.push(grandChild);
+          }
+        });
+
+        // Create paragraph with prefix + inline content
+        if (inlineContent.length > 0) {
+          var newContent = _model.Fragment.from(listPrefix).append(_model.Fragment.fromArray(inlineContent));
+          var newParagraph = paragraphType.create({}, newContent);
+          paragraphs.push(newParagraph);
+        }
+
+        // Recursively process nested lists with increased depth
+        nestedLists.forEach(function (nestedList) {
+          _extract(nestedList, depth + 1);
+        });
+      } else if (child.type === listType) {
+        // Handle list that appears directly as a sibling
+        _extract(child, depth + 1);
+      }
+    });
+  };
+  _extract(node, 0);
+  return paragraphs;
+};
+
+/**
+ * Creates a TransformStep that converts a list to paragraphs with text prefixes.
+ *
+ * Given an array of nodes, processes each list by converting its items
+ * to paragraphs with configurable prefixes.
+ *
+ * Handles nested lists recursively with configurable indentation per level.
+ *
+ * @param config - Configuration for the list-to-text transformation
+ * @returns A TransformStep function
+ */
+var createListToTextStep = exports.createListToTextStep = function createListToTextStep(config) {
+  return function (nodes, context) {
+    var schema = context.schema;
+    var listType = schema.nodes[config.listTypeName];
+    return nodes.flatMap(function (node) {
+      if (node.type === listType) {
+        return extractListItemsAsParagraphs(node, schema, config);
+      }
+      return node;
+    });
+  };
+};

package/dist/cjs/editor-commands/transform-node-utils/transform.js

@@ -7,6 +7,9 @@ exports.getOutputNodes = void 0;
 var _utils = require("../transform-node-utils/utils");
 var _flattenListStep = require("./flattenListStep");
 var _flattenStep = require("./flattenStep");
+var _convertBulletListToTextStep = require("./steps/convertBulletListToTextStep");
+var _convertOrderedListToTextStep = require("./steps/convertOrderedListToTextStep");
+var _convertTaskListToTextStep = require("./steps/convertTaskListToTextStep");
 var _unwrapLayoutStep = require("./steps/unwrapLayoutStep");
 var _stubStep = require("./stubStep");
 var _types = require("./types");
@@ -28,7 +31,7 @@ var wrapIntoPanelStep = function wrapIntoPanelStep(nodes, context) {
 var TRANSFORM_STEPS = {
   atomic: {
     atomic: undefined,
-    container: [_stubStep.stubStep],
+    container: [_wrapStep.wrapStep],
     list: undefined,
     text: undefined
   },
@@ -40,7 +43,7 @@ var TRANSFORM_STEPS = {
   },
   list: {
     atomic: undefined,
-    container: [_stubStep.stubStep],
+    container: [_wrapStep.wrapStep],
     list: [_stubStep.stubStep],
     text: [_flattenListStep.flattenListStep, _unwrapListStep.unwrapListStep]
   },
@@ -94,6 +97,28 @@ var TRANSFORM_STEPS_OVERRIDE = {
     nestedExpand: [_wrapStep.wrapStep],
     layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep],
     panel: [_wrapStep.wrapStep]
+  },
+  bulletList: {
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [_convertBulletListToTextStep.convertBulletListToTextStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
+    layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
+  },
+  orderedList: {
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [_convertOrderedListToTextStep.convertOrderedListToTextStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
+  },
+  taskList: {
+    // Warning: Actuall transformation logic not complete (Skeptical that prosemirror-markdown can be used)
+    blockquote: [_convertTaskListToTextStep.convertTaskListToTextStep, _wrapStep.wrapStep],
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [_convertTaskListToTextStep.convertTaskListToTextStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
+    layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
+  },
+  table: {
+    expand: [_wrapStep.wrapStep],
+    layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
   }
 };
 var getTransformStepsForNodeTypes = function getTransformStepsForNodeTypes(selectedNodeTypeName, targetNodeTypeName) {

package/dist/cjs/editor-commands/transform-node-utils/utils.js

@@ -8,6 +8,7 @@ var _selection = require("@atlaskit/editor-common/selection");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _utils = require("@atlaskit/editor-prosemirror/utils");
 var _editorTables = require("@atlaskit/editor-tables");
+var _utils2 = require("@atlaskit/editor-tables/utils");
 var getSelectedNode = exports.getSelectedNode = function getSelectedNode(selection) {
   if (selection instanceof _state.NodeSelection) {
     return {
@@ -58,29 +59,34 @@ var getTargetNodeTypeNameInContext = exports.getTargetNodeTypeNameInContext = fu
 };
 
 /**
- * Use common expandToBlockRange function, but account for edge cases with lists.
- *
+ * Use common expandToBlockRange function to get the correct range for the selection
+ * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
  * @param selection
  * @param schema
  * @returns
  */
 var expandSelectionToBlockRange = exports.expandSelectionToBlockRange = function expandSelectionToBlockRange(selection, schema) {
-  var isListInSelection = (0, _utils.hasParentNode)(function (node) {
-    return node.type === schema.nodes.bulletList || node.type === schema.nodes.orderedList;
-  })(selection);
-  var _expandToBlockRange = (0, _selection.expandToBlockRange)(selection.$from, selection.$to, function (node) {
-      if (!isListInSelection) {
-        return true;
-      }
-      if (node.type === schema.nodes.bulletList || node.type === schema.nodes.orderedList) {
-        return true;
-      }
+  var nodes = schema.nodes;
+  var nodesNeedToExpandRange = [nodes.listItem, nodes.taskItem];
+
+  // when adding nodes.tableRow, tableHeader, tableCell in nodesNeedToExpandRang,
+  // expandToBlockRange does not return expected table start position, sometimes even freeze editor
+  // so handle table in the below logic
+  if ((0, _utils2.isTableSelected)(selection)) {
+    var table = (0, _utils2.findTable)(selection);
+    if (table) {
+      var $from = selection.$from.doc.resolve(table.pos);
+      var $to = selection.$from.doc.resolve(table.pos + table.node.nodeSize - 1);
+      return {
+        $from: $from,
+        $to: $to
+      };
+    }
+  }
+  return (0, _selection.expandToBlockRange)(selection.$from, selection.$to, function (node) {
+    if (nodesNeedToExpandRange.includes(node.type)) {
       return false;
-    }),
-    $from = _expandToBlockRange.$from,
-    $to = _expandToBlockRange.$to;
-  return {
-    $from: $from,
-    $to: $to
-  };
+    }
+    return true;
+  });
 };

package/dist/es2019/editor-commands/transform-node-utils/steps/convertBulletListToTextStep.js

@@ -0,0 +1,27 @@
+import { createListToTextStep } from './createListToTextStep';
+
+/**
+ * Given an array of nodes, processes each bullet list by converting its items
+ * to paragraphs with "- " prefix.
+ *
+ * Handles nested bullet lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - bulletList()(
+ *     listItem()(p()('Item 1')),
+ *     bulletList()(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('- Item 1')
+ * - p()('   - Sub item 1')
+ */
+export const convertBulletListToTextStep = createListToTextStep({
+  listTypeName: 'bulletList',
+  itemTypeName: 'listItem',
+  indent: '   ',
+  // 3 spaces per nesting level
+  getPrefix: () => '- ',
+  unwrapParagraphContent: true
+});

package/dist/es2019/editor-commands/transform-node-utils/steps/convertOrderedListToTextStep.js

@@ -0,0 +1,55 @@
+import { createListToTextStep } from './createListToTextStep';
+
+/**
+ * Converts a number to a letter (1=a, 2=b, etc.)
+ * For numbers > 26, continues with aa, ab, etc.
+ */
+const numberToLetter = num => {
+  let result = '';
+  let n = num;
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(97 + n % 26) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+};
+
+/**
+ * Gets the appropriate prefix for an ordered list item based on depth and index.
+ * - Level 0: "1. ", "2. ", "3. ", etc.
+ * - Level 1+: "a. ", "b. ", "c. ", etc.
+ */
+const getOrderedListPrefix = (depth, index) => {
+  if (depth === 0) {
+    return `${index}. `;
+  }
+  return `${numberToLetter(index)}. `;
+};
+
+/**
+ * Given an array of nodes, processes each ordered list by converting its items
+ * to paragraphs with numbered prefixes (1., 2., 3.) at the top level and
+ * lettered prefixes (a., b., c.) for nested levels.
+ *
+ * Handles nested ordered lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - orderedList({ order: 1 })(
+ *     listItem()(p()('Item 1')),
+ *     orderedList({ order: 1 })(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('1. Item 1')
+ * - p()('   a. Sub item 1')
+ */
+export const convertOrderedListToTextStep = createListToTextStep({
+  listTypeName: 'orderedList',
+  itemTypeName: 'listItem',
+  indent: '   ',
+  // 3 spaces per nesting level
+  getPrefix: (depth, index) => getOrderedListPrefix(depth, index),
+  unwrapParagraphContent: true
+});

package/dist/es2019/editor-commands/transform-node-utils/steps/convertTaskListToTextStep.js

@@ -0,0 +1,34 @@
+import { createListToTextStep } from './createListToTextStep';
+
+/**
+ * Given an array of nodes, processes each task list by converting its items
+ * to paragraphs with a checkbox prefix. Uses "[] " for unchecked (TODO) tasks
+ * and "[x] " for checked (DONE) tasks.
+ *
+ * Handles nested task lists recursively with 4-space indentation per level.
+ *
+ * This is used when converting a task list to a container that doesn't support
+ * task items (like blockquote).
+ *
+ * @example
+ * Input:
+ * - taskList()(
+ *     taskItem({ state: 'TODO' })('Task list item'),
+ *     taskList()(taskItem({ state: 'DONE' })('Nested done task'))
+ *   )
+ *
+ * Output:
+ * - p()('[] Task list item')
+ * - p()('    [x] Nested done task')
+ */
+export const convertTaskListToTextStep = createListToTextStep({
+  listTypeName: 'taskList',
+  itemTypeName: 'taskItem',
+  indent: '    ',
+  // 4 spaces per nesting level
+  getPrefix: (_, __, itemNode) => {
+    var _itemNode$attrs;
+    return ((_itemNode$attrs = itemNode.attrs) === null || _itemNode$attrs === void 0 ? void 0 : _itemNode$attrs.state) === 'DONE' ? '[x] ' : '[] ';
+  },
+  unwrapParagraphContent: false
+});

package/dist/es2019/editor-commands/transform-node-utils/steps/createListToTextStep.js

@@ -0,0 +1,86 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+
+/**
+ * Configuration for creating a list-to-text transformation step.
+ */
+
+/**
+ * Recursively extracts list items from a list (including nested lists)
+ * and converts them to paragraphs with configurable prefixes and indentation.
+ */
+const extractListItemsAsParagraphs = (node, schema, config) => {
+  const paragraphs = [];
+  const paragraphType = schema.nodes.paragraph;
+  const listType = schema.nodes[config.listTypeName];
+  const itemType = schema.nodes[config.itemTypeName];
+  const extract = (currentNode, depth = 0) => {
+    let itemIndex = 0;
+    currentNode.forEach(child => {
+      if (child.type === itemType) {
+        itemIndex++;
+        const indent = config.indent.repeat(depth);
+        const prefix = config.getPrefix(depth, itemIndex, child);
+        const listPrefix = schema.text(`${indent}${prefix}`);
+
+        // Collect inline content and nested lists separately
+        const inlineContent = [];
+        const nestedLists = [];
+        child.forEach(grandChild => {
+          if (grandChild.type === listType) {
+            nestedLists.push(grandChild);
+          } else if (config.unwrapParagraphContent && grandChild.type === paragraphType) {
+            // Extract content from paragraph nodes
+            grandChild.forEach(content => {
+              inlineContent.push(content);
+            });
+          } else {
+            inlineContent.push(grandChild);
+          }
+        });
+
+        // Create paragraph with prefix + inline content
+        if (inlineContent.length > 0) {
+          const newContent = Fragment.from(listPrefix).append(Fragment.fromArray(inlineContent));
+          const newParagraph = paragraphType.create({}, newContent);
+          paragraphs.push(newParagraph);
+        }
+
+        // Recursively process nested lists with increased depth
+        nestedLists.forEach(nestedList => {
+          extract(nestedList, depth + 1);
+        });
+      } else if (child.type === listType) {
+        // Handle list that appears directly as a sibling
+        extract(child, depth + 1);
+      }
+    });
+  };
+  extract(node, 0);
+  return paragraphs;
+};
+
+/**
+ * Creates a TransformStep that converts a list to paragraphs with text prefixes.
+ *
+ * Given an array of nodes, processes each list by converting its items
+ * to paragraphs with configurable prefixes.
+ *
+ * Handles nested lists recursively with configurable indentation per level.
+ *
+ * @param config - Configuration for the list-to-text transformation
+ * @returns A TransformStep function
+ */
+export const createListToTextStep = config => {
+  return (nodes, context) => {
+    const {
+      schema
+    } = context;
+    const listType = schema.nodes[config.listTypeName];
+    return nodes.flatMap(node => {
+      if (node.type === listType) {
+        return extractListItemsAsParagraphs(node, schema, config);
+      }
+      return node;
+    });
+  };
+};

package/dist/es2019/editor-commands/transform-node-utils/transform.js

@@ -1,6 +1,9 @@
 import { getTargetNodeTypeNameInContext } from '../transform-node-utils/utils';
 import { flattenListStep } from './flattenListStep';
 import { flattenStep } from './flattenStep';
+import { convertBulletListToTextStep } from './steps/convertBulletListToTextStep';
+import { convertOrderedListToTextStep } from './steps/convertOrderedListToTextStep';
+import { convertTaskListToTextStep } from './steps/convertTaskListToTextStep';
 import { unwrapLayoutStep } from './steps/unwrapLayoutStep';
 import { stubStep } from './stubStep';
 import { NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
@@ -23,7 +26,7 @@ const wrapIntoPanelStep = (nodes, context) => {
 const TRANSFORM_STEPS = {
   atomic: {
     atomic: undefined,
-    container: [stubStep],
+    container: [wrapStep],
     list: undefined,
     text: undefined
   },
@@ -35,7 +38,7 @@ const TRANSFORM_STEPS = {
   },
   list: {
     atomic: undefined,
-    container: [stubStep],
+    container: [wrapStep],
     list: [stubStep],
     text: [flattenListStep, unwrapListStep]
   },
@@ -89,6 +92,28 @@ const TRANSFORM_STEPS_OVERRIDE = {
     nestedExpand: [wrapStep],
     layoutSection: [wrapIntoLayoutStep],
     panel: [wrapStep]
+  },
+  bulletList: {
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [convertBulletListToTextStep, flattenStep, wrapStep],
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  orderedList: {
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [convertOrderedListToTextStep, flattenStep, wrapStep],
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  taskList: {
+    // Warning: Actuall transformation logic not complete (Skeptical that prosemirror-markdown can be used)
+    blockquote: [convertTaskListToTextStep, wrapStep],
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [convertTaskListToTextStep, flattenStep, wrapStep],
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  table: {
+    expand: [wrapStep],
+    layoutSection: [wrapIntoLayoutStep]
   }
 };
 const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName) => {

package/dist/es2019/editor-commands/transform-node-utils/utils.js

@@ -1,7 +1,8 @@
 import { expandToBlockRange } from '@atlaskit/editor-common/selection';
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { findParentNodeOfType, hasParentNode } from '@atlaskit/editor-prosemirror/utils';
+import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { CellSelection } from '@atlaskit/editor-tables';
+import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
 export const getSelectedNode = selection => {
   if (selection instanceof NodeSelection) {
     return {
@@ -53,28 +54,36 @@ export const getTargetNodeTypeNameInContext = (nodeTypeName, isNested) => {
 };
 
 /**
- * Use common expandToBlockRange function, but account for edge cases with lists.
- *
+ * Use common expandToBlockRange function to get the correct range for the selection
+ * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
  * @param selection
  * @param schema
  * @returns
  */
 export const expandSelectionToBlockRange = (selection, schema) => {
-  const isListInSelection = hasParentNode(node => node.type === schema.nodes.bulletList || node.type === schema.nodes.orderedList)(selection);
   const {
-    $from,
-    $to
-  } = expandToBlockRange(selection.$from, selection.$to, node => {
-    if (!isListInSelection) {
-      return true;
+    nodes
+  } = schema;
+  const nodesNeedToExpandRange = [nodes.listItem, nodes.taskItem];
+
+  // when adding nodes.tableRow, tableHeader, tableCell in nodesNeedToExpandRang,
+  // expandToBlockRange does not return expected table start position, sometimes even freeze editor
+  // so handle table in the below logic
+  if (isTableSelected(selection)) {
+    const table = findTable(selection);
+    if (table) {
+      const $from = selection.$from.doc.resolve(table.pos);
+      const $to = selection.$from.doc.resolve(table.pos + table.node.nodeSize - 1);
+      return {
+        $from,
+        $to
+      };
     }
-    if (node.type === schema.nodes.bulletList || node.type === schema.nodes.orderedList) {
-      return true;
+  }
+  return expandToBlockRange(selection.$from, selection.$to, node => {
+    if (nodesNeedToExpandRange.includes(node.type)) {
+      return false;
     }
-    return false;
+    return true;
   });
-  return {
-    $from,
-    $to
-  };
 };

package/dist/esm/editor-commands/transform-node-utils/steps/convertBulletListToTextStep.js

@@ -0,0 +1,29 @@
+import { createListToTextStep } from './createListToTextStep';
+
+/**
+ * Given an array of nodes, processes each bullet list by converting its items
+ * to paragraphs with "- " prefix.
+ *
+ * Handles nested bullet lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - bulletList()(
+ *     listItem()(p()('Item 1')),
+ *     bulletList()(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('- Item 1')
+ * - p()('   - Sub item 1')
+ */
+export var convertBulletListToTextStep = createListToTextStep({
+  listTypeName: 'bulletList',
+  itemTypeName: 'listItem',
+  indent: '   ',
+  // 3 spaces per nesting level
+  getPrefix: function getPrefix() {
+    return '- ';
+  },
+  unwrapParagraphContent: true
+});

package/dist/esm/editor-commands/transform-node-utils/steps/convertOrderedListToTextStep.js

@@ -0,0 +1,57 @@
+import { createListToTextStep } from './createListToTextStep';
+
+/**
+ * Converts a number to a letter (1=a, 2=b, etc.)
+ * For numbers > 26, continues with aa, ab, etc.
+ */
+var numberToLetter = function numberToLetter(num) {
+  var result = '';
+  var n = num;
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(97 + n % 26) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+};
+
+/**
+ * Gets the appropriate prefix for an ordered list item based on depth and index.
+ * - Level 0: "1. ", "2. ", "3. ", etc.
+ * - Level 1+: "a. ", "b. ", "c. ", etc.
+ */
+var getOrderedListPrefix = function getOrderedListPrefix(depth, index) {
+  if (depth === 0) {
+    return "".concat(index, ". ");
+  }
+  return "".concat(numberToLetter(index), ". ");
+};
+
+/**
+ * Given an array of nodes, processes each ordered list by converting its items
+ * to paragraphs with numbered prefixes (1., 2., 3.) at the top level and
+ * lettered prefixes (a., b., c.) for nested levels.
+ *
+ * Handles nested ordered lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - orderedList({ order: 1 })(
+ *     listItem()(p()('Item 1')),
+ *     orderedList({ order: 1 })(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('1. Item 1')
+ * - p()('   a. Sub item 1')
+ */
+export var convertOrderedListToTextStep = createListToTextStep({
+  listTypeName: 'orderedList',
+  itemTypeName: 'listItem',
+  indent: '   ',
+  // 3 spaces per nesting level
+  getPrefix: function getPrefix(depth, index) {
+    return getOrderedListPrefix(depth, index);
+  },
+  unwrapParagraphContent: true
+});

package/dist/esm/editor-commands/transform-node-utils/steps/convertTaskListToTextStep.js

@@ -0,0 +1,34 @@
+import { createListToTextStep } from './createListToTextStep';
+
+/**
+ * Given an array of nodes, processes each task list by converting its items
+ * to paragraphs with a checkbox prefix. Uses "[] " for unchecked (TODO) tasks
+ * and "[x] " for checked (DONE) tasks.
+ *
+ * Handles nested task lists recursively with 4-space indentation per level.
+ *
+ * This is used when converting a task list to a container that doesn't support
+ * task items (like blockquote).
+ *
+ * @example
+ * Input:
+ * - taskList()(
+ *     taskItem({ state: 'TODO' })('Task list item'),
+ *     taskList()(taskItem({ state: 'DONE' })('Nested done task'))
+ *   )
+ *
+ * Output:
+ * - p()('[] Task list item')
+ * - p()('    [x] Nested done task')
+ */
+export var convertTaskListToTextStep = createListToTextStep({
+  listTypeName: 'taskList',
+  itemTypeName: 'taskItem',
+  indent: '    ',
+  // 4 spaces per nesting level
+  getPrefix: function getPrefix(_, __, itemNode) {
+    var _itemNode$attrs;
+    return ((_itemNode$attrs = itemNode.attrs) === null || _itemNode$attrs === void 0 ? void 0 : _itemNode$attrs.state) === 'DONE' ? '[x] ' : '[] ';
+  },
+  unwrapParagraphContent: false
+});

package/dist/esm/editor-commands/transform-node-utils/steps/createListToTextStep.js

@@ -0,0 +1,85 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+
+/**
+ * Configuration for creating a list-to-text transformation step.
+ */
+
+/**
+ * Recursively extracts list items from a list (including nested lists)
+ * and converts them to paragraphs with configurable prefixes and indentation.
+ */
+var extractListItemsAsParagraphs = function extractListItemsAsParagraphs(node, schema, config) {
+  var paragraphs = [];
+  var paragraphType = schema.nodes.paragraph;
+  var listType = schema.nodes[config.listTypeName];
+  var itemType = schema.nodes[config.itemTypeName];
+  var _extract = function extract(currentNode) {
+    var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var itemIndex = 0;
+    currentNode.forEach(function (child) {
+      if (child.type === itemType) {
+        itemIndex++;
+        var indent = config.indent.repeat(depth);
+        var prefix = config.getPrefix(depth, itemIndex, child);
+        var listPrefix = schema.text("".concat(indent).concat(prefix));
+
+        // Collect inline content and nested lists separately
+        var inlineContent = [];
+        var nestedLists = [];
+        child.forEach(function (grandChild) {
+          if (grandChild.type === listType) {
+            nestedLists.push(grandChild);
+          } else if (config.unwrapParagraphContent && grandChild.type === paragraphType) {
+            // Extract content from paragraph nodes
+            grandChild.forEach(function (content) {
+              inlineContent.push(content);
+            });
+          } else {
+            inlineContent.push(grandChild);
+          }
+        });
+
+        // Create paragraph with prefix + inline content
+        if (inlineContent.length > 0) {
+          var newContent = Fragment.from(listPrefix).append(Fragment.fromArray(inlineContent));
+          var newParagraph = paragraphType.create({}, newContent);
+          paragraphs.push(newParagraph);
+        }
+
+        // Recursively process nested lists with increased depth
+        nestedLists.forEach(function (nestedList) {
+          _extract(nestedList, depth + 1);
+        });
+      } else if (child.type === listType) {
+        // Handle list that appears directly as a sibling
+        _extract(child, depth + 1);
+      }
+    });
+  };
+  _extract(node, 0);
+  return paragraphs;
+};
+
+/**
+ * Creates a TransformStep that converts a list to paragraphs with text prefixes.
+ *
+ * Given an array of nodes, processes each list by converting its items
+ * to paragraphs with configurable prefixes.
+ *
+ * Handles nested lists recursively with configurable indentation per level.
+ *
+ * @param config - Configuration for the list-to-text transformation
+ * @returns A TransformStep function
+ */
+export var createListToTextStep = function createListToTextStep(config) {
+  return function (nodes, context) {
+    var schema = context.schema;
+    var listType = schema.nodes[config.listTypeName];
+    return nodes.flatMap(function (node) {
+      if (node.type === listType) {
+        return extractListItemsAsParagraphs(node, schema, config);
+      }
+      return node;
+    });
+  };
+};

package/dist/esm/editor-commands/transform-node-utils/transform.js

@@ -1,6 +1,9 @@
 import { getTargetNodeTypeNameInContext } from '../transform-node-utils/utils';
 import { flattenListStep } from './flattenListStep';
 import { flattenStep } from './flattenStep';
+import { convertBulletListToTextStep } from './steps/convertBulletListToTextStep';
+import { convertOrderedListToTextStep } from './steps/convertOrderedListToTextStep';
+import { convertTaskListToTextStep } from './steps/convertTaskListToTextStep';
 import { unwrapLayoutStep } from './steps/unwrapLayoutStep';
 import { stubStep } from './stubStep';
 import { NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
@@ -23,7 +26,7 @@ var wrapIntoPanelStep = function wrapIntoPanelStep(nodes, context) {
 var TRANSFORM_STEPS = {
   atomic: {
     atomic: undefined,
-    container: [stubStep],
+    container: [wrapStep],
     list: undefined,
     text: undefined
   },
@@ -35,7 +38,7 @@ var TRANSFORM_STEPS = {
   },
   list: {
     atomic: undefined,
-    container: [stubStep],
+    container: [wrapStep],
     list: [stubStep],
     text: [flattenListStep, unwrapListStep]
   },
@@ -89,6 +92,28 @@ var TRANSFORM_STEPS_OVERRIDE = {
     nestedExpand: [wrapStep],
     layoutSection: [wrapIntoLayoutStep],
     panel: [wrapStep]
+  },
+  bulletList: {
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [convertBulletListToTextStep, flattenStep, wrapStep],
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  orderedList: {
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [convertOrderedListToTextStep, flattenStep, wrapStep],
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  taskList: {
+    // Warning: Actuall transformation logic not complete (Skeptical that prosemirror-markdown can be used)
+    blockquote: [convertTaskListToTextStep, wrapStep],
+    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    codeBlock: [convertTaskListToTextStep, flattenStep, wrapStep],
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  table: {
+    expand: [wrapStep],
+    layoutSection: [wrapIntoLayoutStep]
   }
 };
 var getTransformStepsForNodeTypes = function getTransformStepsForNodeTypes(selectedNodeTypeName, targetNodeTypeName) {

package/dist/esm/editor-commands/transform-node-utils/utils.js

@@ -1,7 +1,8 @@
 import { expandToBlockRange } from '@atlaskit/editor-common/selection';
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { findParentNodeOfType, hasParentNode } from '@atlaskit/editor-prosemirror/utils';
+import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { CellSelection } from '@atlaskit/editor-tables';
+import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
 export var getSelectedNode = function getSelectedNode(selection) {
   if (selection instanceof NodeSelection) {
     return {
@@ -52,29 +53,34 @@ export var getTargetNodeTypeNameInContext = function getTargetNodeTypeNameInCont
 };
 
 /**
- * Use common expandToBlockRange function, but account for edge cases with lists.
- *
+ * Use common expandToBlockRange function to get the correct range for the selection
+ * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
  * @param selection
  * @param schema
  * @returns
  */
 export var expandSelectionToBlockRange = function expandSelectionToBlockRange(selection, schema) {
-  var isListInSelection = hasParentNode(function (node) {
-    return node.type === schema.nodes.bulletList || node.type === schema.nodes.orderedList;
-  })(selection);
-  var _expandToBlockRange = expandToBlockRange(selection.$from, selection.$to, function (node) {
-      if (!isListInSelection) {
-        return true;
-      }
-      if (node.type === schema.nodes.bulletList || node.type === schema.nodes.orderedList) {
-        return true;
-      }
+  var nodes = schema.nodes;
+  var nodesNeedToExpandRange = [nodes.listItem, nodes.taskItem];
+
+  // when adding nodes.tableRow, tableHeader, tableCell in nodesNeedToExpandRang,
+  // expandToBlockRange does not return expected table start position, sometimes even freeze editor
+  // so handle table in the below logic
+  if (isTableSelected(selection)) {
+    var table = findTable(selection);
+    if (table) {
+      var $from = selection.$from.doc.resolve(table.pos);
+      var $to = selection.$from.doc.resolve(table.pos + table.node.nodeSize - 1);
+      return {
+        $from: $from,
+        $to: $to
+      };
+    }
+  }
+  return expandToBlockRange(selection.$from, selection.$to, function (node) {
+    if (nodesNeedToExpandRange.includes(node.type)) {
       return false;
-    }),
-    $from = _expandToBlockRange.$from,
-    $to = _expandToBlockRange.$to;
-  return {
-    $from: $from,
-    $to: $to
-  };
+    }
+    return true;
+  });
 };

package/dist/types/editor-commands/transform-node-utils/steps/convertBulletListToTextStep.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Given an array of nodes, processes each bullet list by converting its items
+ * to paragraphs with "- " prefix.
+ *
+ * Handles nested bullet lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - bulletList()(
+ *     listItem()(p()('Item 1')),
+ *     bulletList()(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('- Item 1')
+ * - p()('   - Sub item 1')
+ */
+export declare const convertBulletListToTextStep: import("../types").TransformStep;

package/dist/types/editor-commands/transform-node-utils/steps/convertOrderedListToTextStep.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Given an array of nodes, processes each ordered list by converting its items
+ * to paragraphs with numbered prefixes (1., 2., 3.) at the top level and
+ * lettered prefixes (a., b., c.) for nested levels.
+ *
+ * Handles nested ordered lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - orderedList({ order: 1 })(
+ *     listItem()(p()('Item 1')),
+ *     orderedList({ order: 1 })(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('1. Item 1')
+ * - p()('   a. Sub item 1')
+ */
+export declare const convertOrderedListToTextStep: import("../types").TransformStep;

package/dist/types/editor-commands/transform-node-utils/steps/convertTaskListToTextStep.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Given an array of nodes, processes each task list by converting its items
+ * to paragraphs with a checkbox prefix. Uses "[] " for unchecked (TODO) tasks
+ * and "[x] " for checked (DONE) tasks.
+ *
+ * Handles nested task lists recursively with 4-space indentation per level.
+ *
+ * This is used when converting a task list to a container that doesn't support
+ * task items (like blockquote).
+ *
+ * @example
+ * Input:
+ * - taskList()(
+ *     taskItem({ state: 'TODO' })('Task list item'),
+ *     taskList()(taskItem({ state: 'DONE' })('Nested done task'))
+ *   )
+ *
+ * Output:
+ * - p()('[] Task list item')
+ * - p()('    [x] Nested done task')
+ */
+export declare const convertTaskListToTextStep: import("../types").TransformStep;

package/dist/types/editor-commands/transform-node-utils/steps/createListToTextStep.d.ts

@@ -0,0 +1,38 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { TransformStep } from '../types';
+/**
+ * Configuration for creating a list-to-text transformation step.
+ */
+export interface ListToTextConfig {
+    /**
+     * Generate prefix text for a list item.
+     * @param depth - Nesting depth (0 = top level)
+     * @param index - 1-based index within current list
+     * @param itemNode - The item node (for reading attrs like task state)
+     */
+    getPrefix: (depth: number, index: number, itemNode: PMNode) => string;
+    /** Indentation string per nesting level (e.g., '   ' for 3 spaces) */
+    indent: string;
+    /** Name of the item node type (e.g., 'listItem', 'taskItem') */
+    itemTypeName: string;
+    /** Name of the list node type (e.g., 'bulletList', 'orderedList', 'taskList') */
+    listTypeName: string;
+    /**
+     * Whether to unwrap content from paragraph children.
+     * - bullet/ordered lists = true (content is wrapped in paragraphs)
+     * - task lists = false (inline content is a direct child)
+     */
+    unwrapParagraphContent: boolean;
+}
+/**
+ * Creates a TransformStep that converts a list to paragraphs with text prefixes.
+ *
+ * Given an array of nodes, processes each list by converting its items
+ * to paragraphs with configurable prefixes.
+ *
+ * Handles nested lists recursively with configurable indentation per level.
+ *
+ * @param config - Configuration for the list-to-text transformation
+ * @returns A TransformStep function
+ */
+export declare const createListToTextStep: (config: ListToTextConfig) => TransformStep;

package/dist/types/editor-commands/transform-node-utils/utils.d.ts

@@ -5,8 +5,8 @@ import type { NodeTypeName } from './types';
 export declare const getSelectedNode: (selection: Selection) => ContentNodeWithPos | undefined;
 export declare const getTargetNodeTypeNameInContext: (nodeTypeName: NodeTypeName | null, isNested?: boolean) => NodeTypeName | null;
 /**
- * Use common expandToBlockRange function, but account for edge cases with lists.
- *
+ * Use common expandToBlockRange function to get the correct range for the selection
+ * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
  * @param selection
  * @param schema
  * @returns

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/convertBulletListToTextStep.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Given an array of nodes, processes each bullet list by converting its items
+ * to paragraphs with "- " prefix.
+ *
+ * Handles nested bullet lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - bulletList()(
+ *     listItem()(p()('Item 1')),
+ *     bulletList()(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('- Item 1')
+ * - p()('   - Sub item 1')
+ */
+export declare const convertBulletListToTextStep: import("../types").TransformStep;

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/convertOrderedListToTextStep.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Given an array of nodes, processes each ordered list by converting its items
+ * to paragraphs with numbered prefixes (1., 2., 3.) at the top level and
+ * lettered prefixes (a., b., c.) for nested levels.
+ *
+ * Handles nested ordered lists recursively with 3-space indentation per level.
+ *
+ * @example
+ * Input:
+ * - orderedList({ order: 1 })(
+ *     listItem()(p()('Item 1')),
+ *     orderedList({ order: 1 })(listItem()(p()('Sub item 1')))
+ *   )
+ *
+ * Output:
+ * - p()('1. Item 1')
+ * - p()('   a. Sub item 1')
+ */
+export declare const convertOrderedListToTextStep: import("../types").TransformStep;

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/convertTaskListToTextStep.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Given an array of nodes, processes each task list by converting its items
+ * to paragraphs with a checkbox prefix. Uses "[] " for unchecked (TODO) tasks
+ * and "[x] " for checked (DONE) tasks.
+ *
+ * Handles nested task lists recursively with 4-space indentation per level.
+ *
+ * This is used when converting a task list to a container that doesn't support
+ * task items (like blockquote).
+ *
+ * @example
+ * Input:
+ * - taskList()(
+ *     taskItem({ state: 'TODO' })('Task list item'),
+ *     taskList()(taskItem({ state: 'DONE' })('Nested done task'))
+ *   )
+ *
+ * Output:
+ * - p()('[] Task list item')
+ * - p()('    [x] Nested done task')
+ */
+export declare const convertTaskListToTextStep: import("../types").TransformStep;

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/createListToTextStep.d.ts

@@ -0,0 +1,38 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { TransformStep } from '../types';
+/**
+ * Configuration for creating a list-to-text transformation step.
+ */
+export interface ListToTextConfig {
+    /**
+     * Generate prefix text for a list item.
+     * @param depth - Nesting depth (0 = top level)
+     * @param index - 1-based index within current list
+     * @param itemNode - The item node (for reading attrs like task state)
+     */
+    getPrefix: (depth: number, index: number, itemNode: PMNode) => string;
+    /** Indentation string per nesting level (e.g., '   ' for 3 spaces) */
+    indent: string;
+    /** Name of the item node type (e.g., 'listItem', 'taskItem') */
+    itemTypeName: string;
+    /** Name of the list node type (e.g., 'bulletList', 'orderedList', 'taskList') */
+    listTypeName: string;
+    /**
+     * Whether to unwrap content from paragraph children.
+     * - bullet/ordered lists = true (content is wrapped in paragraphs)
+     * - task lists = false (inline content is a direct child)
+     */
+    unwrapParagraphContent: boolean;
+}
+/**
+ * Creates a TransformStep that converts a list to paragraphs with text prefixes.
+ *
+ * Given an array of nodes, processes each list by converting its items
+ * to paragraphs with configurable prefixes.
+ *
+ * Handles nested lists recursively with configurable indentation per level.
+ *
+ * @param config - Configuration for the list-to-text transformation
+ * @returns A TransformStep function
+ */
+export declare const createListToTextStep: (config: ListToTextConfig) => TransformStep;

package/dist/types-ts4.5/editor-commands/transform-node-utils/utils.d.ts

@@ -5,8 +5,8 @@ import type { NodeTypeName } from './types';
 export declare const getSelectedNode: (selection: Selection) => ContentNodeWithPos | undefined;
 export declare const getTargetNodeTypeNameInContext: (nodeTypeName: NodeTypeName | null, isNested?: boolean) => NodeTypeName | null;
 /**
- * Use common expandToBlockRange function, but account for edge cases with lists.
- *
+ * Use common expandToBlockRange function to get the correct range for the selection
+ * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
  * @param selection
  * @param schema
  * @returns

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-block-menu",
-	"version": "5.1.11",
+	"version": "5.2.1",
 	"description": "BlockMenu plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -44,7 +44,7 @@
 		"@atlaskit/platform-feature-flags": "^1.1.0",
 		"@atlaskit/platform-feature-flags-react": "^0.4.0",
 		"@atlaskit/primitives": "^16.4.0",
-		"@atlaskit/tmp-editor-statsig": "^15.6.0",
+		"@atlaskit/tmp-editor-statsig": "^15.7.0",
 		"@atlaskit/tokens": "^8.4.0",
 		"@babel/runtime": "^7.0.0"
 	},