@atlaskit/editor-plugin-block-menu 0.0.12 → 0.0.14

package/dist/esm/editor-commands/transforms/container-transforms.js

@@ -0,0 +1,54 @@
+import { isBlockNodeType, isListNodeType, isContainerNodeType } from './utils';
+
+/**
+ * Transform selection to container type
+ */
+export var transformToContainer = function transformToContainer() {
+  return null;
+};
+
+/**
+ * Transform container nodes (panel, expand, blockquote)
+ */
+export var transformContainerNode = function transformContainerNode(_ref) {
+  var tr = _ref.tr,
+    sourcePos = _ref.sourcePos,
+    targetNodeType = _ref.targetNodeType,
+    targetAttrs = _ref.targetAttrs;
+  if (sourcePos === null) {
+    return null;
+  }
+
+  // Transform container to block type - unwrap and convert content
+  if (isBlockNodeType(targetNodeType)) {
+    return unwrapAndConvertToBlockType();
+  }
+
+  // Transform container to list type
+  if (isListNodeType(targetNodeType)) {
+    return unwrapAndConvertToList();
+  }
+
+  // Transform between container types
+  if (isContainerNodeType(targetNodeType)) {
+    tr.setNodeMarkup(sourcePos, targetNodeType, targetAttrs);
+    return tr;
+  }
+  return null;
+};
+
+/**
+ * Unwrap container node and convert content to block type
+ */
+export var unwrapAndConvertToBlockType = function unwrapAndConvertToBlockType() {
+  // Convert to block type directly
+  return null;
+};
+
+/**
+ * Unwrap container node and convert content to list
+ */
+export var unwrapAndConvertToList = function unwrapAndConvertToList() {
+  // Convert to list directly
+  return null;
+};

package/dist/esm/editor-commands/transforms/list-transforms.js

@@ -0,0 +1,48 @@
+import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
+
+/**
+ * Transform selection to list type
+ */
+export var transformToList = function transformToList() {
+  return null;
+};
+
+/**
+ * Transform list nodes
+ */
+export var transformListNode = function transformListNode(_ref) {
+  var targetNodeType = _ref.targetNodeType;
+  // Transform list to block type
+  if (isBlockNodeType(targetNodeType)) {
+    // Lift list items out of the list and convert to target block type
+    return null;
+  }
+
+  // Transform list to container type
+  if (isContainerNodeType(targetNodeType)) {
+    // Lift list items out of the list and convert to container type
+    return null;
+  }
+
+  // Transform between list types
+  if (isListNodeType(targetNodeType)) {
+    // Lift list items out of the list and convert to the other list type
+    return null;
+  }
+  return null;
+};
+
+/**
+ * Lift list content and convert to block type
+ */
+export var liftListToBlockType = function liftListToBlockType() {
+  // Convert to target block type directly
+  return null;
+};
+
+/**
+ * Transform between different list types
+ */
+export var transformBetweenListTypes = function transformBetweenListTypes() {
+  return null;
+};

package/dist/esm/editor-commands/transforms/transformNodeToTargetType.js

@@ -0,0 +1,44 @@
+import { transformBlockNode } from './block-transforms';
+import { transformContainerNode } from './container-transforms';
+import { transformListNode } from './list-transforms';
+import { getTargetNodeInfo, isBlockNode, isListNode, isContainerNode } from './utils';
+export function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
+  var nodes = tr.doc.type.schema.nodes;
+  var targetNodeInfo = getTargetNodeInfo(targetType, nodes);
+  if (!targetNodeInfo) {
+    return null;
+  }
+  var targetNodeType = targetNodeInfo.nodeType,
+    targetAttrs = targetNodeInfo.attrs;
+
+  // Early return if trying to transform to the same type
+  if (sourceNode.type === targetNodeType) {
+    return tr; // No transformation needed
+  }
+
+  // Prepare transformation context
+  var transformationContext = {
+    tr: tr,
+    sourceNode: sourceNode,
+    sourcePos: sourcePos,
+    targetNodeType: targetNodeType,
+    targetAttrs: targetAttrs
+  };
+
+  // Route to appropriate transformation strategy based on source node type
+  try {
+    if (isBlockNode(sourceNode)) {
+      return transformBlockNode(transformationContext);
+    }
+    if (isListNode(sourceNode)) {
+      return transformListNode(transformationContext);
+    }
+    if (isContainerNode(sourceNode)) {
+      return transformContainerNode(transformationContext);
+    }
+    return null;
+  } catch (e) {
+    // Node transformation failed
+    return null;
+  }
+}

package/dist/esm/editor-commands/transforms/types.js

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

package/dist/esm/editor-commands/transforms/utils.js

@@ -0,0 +1,103 @@
+export var getTargetNodeInfo = function getTargetNodeInfo(targetType, nodes) {
+  switch (targetType) {
+    case 'heading1':
+      return {
+        nodeType: nodes.heading,
+        attrs: {
+          level: 1
+        }
+      };
+    case 'heading2':
+      return {
+        nodeType: nodes.heading,
+        attrs: {
+          level: 2
+        }
+      };
+    case 'heading3':
+      return {
+        nodeType: nodes.heading,
+        attrs: {
+          level: 3
+        }
+      };
+    case 'heading4':
+      return {
+        nodeType: nodes.heading,
+        attrs: {
+          level: 4
+        }
+      };
+    case 'heading5':
+      return {
+        nodeType: nodes.heading,
+        attrs: {
+          level: 5
+        }
+      };
+    case 'heading6':
+      return {
+        nodeType: nodes.heading,
+        attrs: {
+          level: 6
+        }
+      };
+    case 'paragraph':
+      return {
+        nodeType: nodes.paragraph
+      };
+    case 'blockquote':
+      return {
+        nodeType: nodes.blockquote
+      };
+    case 'expand':
+      return {
+        nodeType: nodes.expand
+      };
+    case 'panel':
+      return {
+        nodeType: nodes.panel,
+        attrs: {
+          panelType: 'info'
+        }
+      };
+    case 'codeblock':
+      return {
+        nodeType: nodes.codeBlock
+      };
+    case 'bulletList':
+      return {
+        nodeType: nodes.bulletList
+      };
+    case 'orderedList':
+      return {
+        nodeType: nodes.orderedList
+      };
+    case 'taskList':
+      return {
+        nodeType: nodes.taskList
+      };
+    default:
+      return null;
+  }
+};
+
+// Helper functions to categorize node types
+export var isBlockNode = function isBlockNode(node) {
+  return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
+};
+export var isListNode = function isListNode(node) {
+  return ['bulletList', 'orderedList', 'taskList', 'listItem'].includes(node.type.name);
+};
+export var isContainerNode = function isContainerNode(node) {
+  return ['panel', 'expand', 'blockquote'].includes(node.type.name);
+};
+export var isBlockNodeType = function isBlockNodeType(nodeType) {
+  return ['paragraph', 'heading', 'codeBlock'].includes(nodeType.name);
+};
+export var isListNodeType = function isListNodeType(nodeType) {
+  return ['bulletList', 'orderedList', 'taskList'].includes(nodeType.name);
+};
+export var isContainerNodeType = function isContainerNodeType(nodeType) {
+  return ['panel', 'expand', 'blockquote'].includes(nodeType.name);
+};

package/dist/esm/ui/block-menu-components.js

@@ -1,10 +1,9 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import React from 'react';
-import { ToolbarDropdownItem, ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
+import { ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
 import ChangesIcon from '@atlaskit/icon/core/changes';
 import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
-import ListBulletedIcon from '@atlaskit/icon/core/list-bulleted';
-import TaskIcon from '@atlaskit/icon/core/task';
+import { fg } from '@atlaskit/platform-feature-flags';
 import CopyBlockMenuItem from './copy-block';
 import { CopyLinkDropdownItem } from './copy-link';
 import { DeleteDropdownItem } from './delete-button';
@@ -39,23 +38,64 @@ var getMoveUpMoveDownMenuComponents = function getMoveUpMoveDownMenuComponents(a
     }
   }];
 };
-export var getBlockMenuComponents = function getBlockMenuComponents(_ref) {
-  var api = _ref.api,
-    config = _ref.config;
+var getFormatMenuComponents = function getFormatMenuComponents() {
   return [{
+    type: 'block-menu-nested',
+    key: 'nested-menu-format',
+    parent: {
+      type: 'block-menu-section',
+      key: 'block-menu-section-primary',
+      rank: 100
+    },
+    component: function component() {
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          children: null
+        },
+        children = _ref.children;
+      return /*#__PURE__*/React.createElement(ToolbarNestedDropdownMenu, {
+        text: "Format",
+        elemBefore: /*#__PURE__*/React.createElement(ChangesIcon, {
+          label: ""
+        }),
+        elemAfter: /*#__PURE__*/React.createElement(ChevronRightIcon, {
+          label: 'example nested menu'
+        })
+      }, children);
+    }
+  }, {
     type: 'block-menu-section',
-    key: 'block-menu-section-format',
+    key: 'nested-menu-format-section-primary',
+    parent: {
+      type: 'block-menu-nested',
+      key: 'nested-menu-format',
+      rank: 100
+    },
+    component: function component() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          children: null
+        },
+        children = _ref2.children;
+      return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, children);
+    }
+  }];
+};
+export var getBlockMenuComponents = function getBlockMenuComponents(_ref3) {
+  var api = _ref3.api,
+    config = _ref3.config;
+  return [].concat(_toConsumableArray(fg('platform_editor_block_menu_format') ? getFormatMenuComponents() : []), [{
+    type: 'block-menu-section',
+    key: 'block-menu-section-primary',
     rank: 100,
-    component: function component(_ref2) {
-      var children = _ref2.children;
+    component: function component(_ref4) {
+      var children = _ref4.children;
       return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, children);
     }
   }, {
     type: 'block-menu-section',
     key: 'block-menu-section-copy',
     rank: 200,
-    component: function component(_ref3) {
-      var children = _ref3.children;
+    component: function component(_ref5) {
+      var children = _ref5.children;
       return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, {
         hasSeparator: true
       }, children);
@@ -91,8 +131,8 @@ export var getBlockMenuComponents = function getBlockMenuComponents(_ref) {
     type: 'block-menu-section',
     key: 'block-menu-section-move-up-down',
     rank: 300,
-    component: function component(_ref4) {
-      var children = _ref4.children;
+    component: function component(_ref6) {
+      var children = _ref6.children;
       return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, {
         hasSeparator: true
       }, children);
@@ -101,40 +141,13 @@ export var getBlockMenuComponents = function getBlockMenuComponents(_ref) {
     type: 'block-menu-section',
     key: 'block-menu-section-delete',
     rank: 400,
-    component: function component(_ref5) {
-      var children = _ref5.children;
+    component: function component(_ref7) {
+      var children = _ref7.children;
       return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, {
         hasSeparator: true
       }, children);
     }
-  }, {
-    type: 'block-menu-nested',
-    key: 'nested-menu',
-    parent: {
-      type: 'block-menu-section',
-      key: 'block-menu-section-format',
-      rank: 100
-    },
-    component: function component() {
-      return /*#__PURE__*/React.createElement(ToolbarNestedDropdownMenu, {
-        text: "Format",
-        elemBefore: /*#__PURE__*/React.createElement(ChangesIcon, {
-          label: ""
-        }),
-        elemAfter: /*#__PURE__*/React.createElement(ChevronRightIcon, {
-          label: 'example nested menu'
-        })
-      }, /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, /*#__PURE__*/React.createElement(ToolbarDropdownItem, {
-        elemBefore: /*#__PURE__*/React.createElement(TaskIcon, {
-          label: ""
-        })
-      }, "Action item"), /*#__PURE__*/React.createElement(ToolbarDropdownItem, {
-        elemBefore: /*#__PURE__*/React.createElement(ListBulletedIcon, {
-          label: ""
-        })
-      }, "Bullet list")));
-    }
-  }].concat(_toConsumableArray(getMoveUpMoveDownMenuComponents(api)), [{
+  }], _toConsumableArray(getMoveUpMoveDownMenuComponents(api)), [{
     type: 'block-menu-item',
     key: 'block-menu-item-delete',
     parent: {

package/dist/esm/ui/block-menu-renderer.js

@@ -3,8 +3,8 @@ import React, { Fragment } from 'react';
 var NoOp = function NoOp(props) {
   return null;
 };
-var isMenuSection = function isMenuSection(component) {
-  return component.type === 'block-menu-section';
+var isNonNestedMenuSection = function isNonNestedMenuSection(component) {
+  return component.type === 'block-menu-section' && !('parent' in component);
 };
 var isMenuItem = function isMenuItem(component) {
   return component.type === 'block-menu-item';
@@ -12,31 +12,68 @@ var isMenuItem = function isMenuItem(component) {
 var isNestedMenu = function isNestedMenu(component) {
   return component.type === 'block-menu-nested';
 };
+var isNestedMenuSection = function isNestedMenuSection(component) {
+  return 'parent' in component && component.parent !== undefined && component.parent.type === 'block-menu-nested';
+};
 var getSortedChildren = function getSortedChildren(components, parentKey) {
   return components.filter(function (component) {
-    return component.parent.key === parentKey;
+    return 'parent' in component && component.parent !== undefined && component.parent.key === parentKey;
   }).sort(function (a, b) {
     return (a.parent.rank || 0) - (b.parent.rank || 0);
   });
 };
-var getSortedSections = function getSortedSections(components) {
-  return components.filter(isMenuSection).sort(function (a, b) {
+var getSortedNestedSections = function getSortedNestedSections(components, parentKey) {
+  var nestedMenuSections = components.filter(isNestedMenuSection);
+  var nestedMenuSectionsWithParent = nestedMenuSections.filter(function (section) {
+    return section.parent !== undefined;
+  });
+  return getSortedChildren(nestedMenuSectionsWithParent, parentKey);
+};
+var getSortedNonNestedSections = function getSortedNonNestedSections(components) {
+  return components.filter(isNonNestedMenuSection).sort(function (a, b) {
     return (a.rank || 0) - (b.rank || 0);
   });
 };
 export var BlockMenuRenderer = function BlockMenuRenderer(_ref) {
   var components = _ref.components,
     fallbacks = _ref.fallbacks;
-  var menuSections = getSortedSections(components);
+  var menuSections = getSortedNonNestedSections(components);
   var menuItems = components.filter(isMenuItem);
   var nestedMenus = components.filter(isNestedMenu);
   return /*#__PURE__*/React.createElement(Fragment, null, menuSections.map(function (section) {
-    var children = getSortedChildren([].concat(_toConsumableArray(menuItems), _toConsumableArray(nestedMenus)), section.key).map(function (item) {
-      var ItemComponent = item.component || fallbacks.item || NoOp;
-      return /*#__PURE__*/React.createElement(ItemComponent, {
-        key: item.key
+    // Get all items for the current section, including nested menus, and sort them by rank
+    var currentSectionItemsSorted = getSortedChildren([].concat(_toConsumableArray(menuItems), _toConsumableArray(nestedMenus)), section.key);
+
+    // iterate over the current section items, if it is nested menu, get their children, sort them
+    // if they are menu items, just render as they are sorted above
+    var getChildrenWithNestedItems = function getChildrenWithNestedItems(items) {
+      return items.map(function (item) {
+        if (isNestedMenu(item)) {
+          var sortedNestedSections = getSortedNestedSections(components, item.key);
+          return sortedNestedSections.map(function (section) {
+            var sortedNestedMenuItems = getSortedChildren(menuItems, section.key);
+            var NestedMenuComponent = item.component || fallbacks.nestedMenu || NoOp;
+            var NestedSection = section.component || fallbacks.section || NoOp;
+            return /*#__PURE__*/React.createElement(NestedMenuComponent, {
+              key: item.key
+            }, /*#__PURE__*/React.createElement(NestedSection, {
+              key: section.key
+            }, sortedNestedMenuItems.map(function (nestedItem) {
+              var NestedMenuItemComponent = nestedItem.component || fallbacks.item || NoOp;
+              return /*#__PURE__*/React.createElement(NestedMenuItemComponent, {
+                key: nestedItem.key
+              });
+            })));
+          });
+        } else {
+          var ItemComponent = item.component || fallbacks.item || NoOp;
+          return /*#__PURE__*/React.createElement(ItemComponent, {
+            key: item.key
+          });
+        }
       });
-    });
+    };
+    var children = getChildrenWithNestedItems(currentSectionItemsSorted);
     var SectionComponent = section.component || fallbacks.section || NoOp;
     return /*#__PURE__*/React.createElement(SectionComponent, {
       key: section.key

package/dist/types/blockMenuPluginType.d.ts

@@ -1,13 +1,18 @@
-import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { NextEditorPlugin, OptionalPlugin, EditorCommand } from '@atlaskit/editor-common/types';
 import type { BlockControlsPlugin } from '@atlaskit/editor-plugin-block-controls';
 import type { DecorationsPlugin } from '@atlaskit/editor-plugin-decorations';
 import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
 import type { UserIntentPlugin } from '@atlaskit/editor-plugin-user-intent';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { FormatNodeTargetType } from './editor-commands/transforms/types';
 export type BlockMenuPlugin = NextEditorPlugin<'blockMenu', {
     actions: {
         getBlockMenuComponents: () => Array<RegisterBlockMenuComponent>;
         registerBlockMenuComponents: (blockMenuComponents: Array<RegisterBlockMenuComponent>) => void;
     };
+    commands: {
+        formatNode: (currentNode: PMNode, targetType: FormatNodeTargetType) => EditorCommand;
+    };
     dependencies: [
         OptionalPlugin<BlockControlsPlugin>,
         OptionalPlugin<UserIntentPlugin>,
@@ -33,6 +38,19 @@ type WithRank<T> = T & {
 export type Parent<T> = WithRank<T>;
 type ComponentType = BlockMenuSection | BlockMenuItem | BlockMenuNested;
 export type ComponentTypes = Array<ComponentType>;
+/**
+ * The relationship between BlockMenuItem, BlockMenuSection, BlockMenuNested
+ * BlockMenuSection can have BlockMenuItem or BlockMenuNested as children
+ * BlockMenuNested can have BlockMenuSection as children,
+ * BlockMenuNested, with BlockMenuSection and BlockMenuItem, is a nested menu
+ *  _______________________________________
+ * | Block menu (no typing)
+ * |  |BlockMenuSection
+ * |  |  |BlockMenuItem
+ * |  |  |BlockMenuNested
+ * |  |  |  |BlockMenuSection
+ * |  |  |  |  |BlockMenuItem
+ */
 type BlockMenuItem = {
     key: string;
     type: 'block-menu-item';
@@ -45,10 +63,15 @@ type BlockMenuNested = {
     key: string;
     type: 'block-menu-nested';
 };
-export type BlockMenuNestedComponent = () => React.ReactNode;
+export type BlockMenuNestedComponent = (props?: {
+    children: React.ReactNode;
+}) => React.ReactNode;
 export type BlockMenuSectionComponent = (props: {
     children: React.ReactNode;
 }) => React.ReactNode;
+export type BlockMenuNestedSectionComponent = (props: {
+    children: React.ReactNode;
+}) => React.ReactNode;
 export type BlockMenuItemComponent = () => React.ReactNode;
 export type RegisterBlockMenuNested = BlockMenuNested & {
     component?: BlockMenuNestedComponent;
@@ -56,7 +79,8 @@ export type RegisterBlockMenuNested = BlockMenuNested & {
 };
 export type RegisterBlockMenuSection = BlockMenuSection & {
     component?: BlockMenuSectionComponent;
-    rank: number;
+    parent?: Parent<BlockMenuNested>;
+    rank?: number;
 };
 export type RegisterBlockMenuItem = BlockMenuItem & {
     component?: BlockMenuItemComponent;

package/dist/types/editor-commands/formatNode.d.ts

@@ -0,0 +1,9 @@
+import type { EditorCommand } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { FormatNodeTargetType } from './transforms/types';
+/**
+ * Formats the current node or selection to the specified target type
+ * @param currentNode - The current node
+ * @param targetType - The target node type to convert to
+ */
+export declare const formatNode: (currentNode: PMNode, targetType: FormatNodeTargetType) => EditorCommand;

package/dist/types/editor-commands/transforms/block-transforms.d.ts

@@ -0,0 +1,5 @@
+import type { TransformFunction } from './types';
+/**
+ * Transform block nodes (paragraph, heading, codeblock)
+ */
+export declare const transformBlockNode: TransformFunction;

package/dist/types/editor-commands/transforms/container-transforms.d.ts

@@ -0,0 +1,17 @@
+import type { TransformFunction } from './types';
+/**
+ * Transform selection to container type
+ */
+export declare const transformToContainer: () => null;
+/**
+ * Transform container nodes (panel, expand, blockquote)
+ */
+export declare const transformContainerNode: TransformFunction;
+/**
+ * Unwrap container node and convert content to block type
+ */
+export declare const unwrapAndConvertToBlockType: () => null;
+/**
+ * Unwrap container node and convert content to list
+ */
+export declare const unwrapAndConvertToList: () => null;

package/dist/types/editor-commands/transforms/list-transforms.d.ts

@@ -0,0 +1,17 @@
+import type { TransformFunction } from './types';
+/**
+ * Transform selection to list type
+ */
+export declare const transformToList: () => null;
+/**
+ * Transform list nodes
+ */
+export declare const transformListNode: TransformFunction;
+/**
+ * Lift list content and convert to block type
+ */
+export declare const liftListToBlockType: () => null;
+/**
+ * Transform between different list types
+ */
+export declare const transformBetweenListTypes: () => null;

package/dist/types/editor-commands/transforms/transformNodeToTargetType.d.ts

@@ -0,0 +1,4 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { FormatNodeTargetType } from './types';
+export declare function transformNodeToTargetType(tr: Transaction, sourceNode: PMNode, sourcePos: number | null, targetType: FormatNodeTargetType): Transaction | null;

package/dist/types/editor-commands/transforms/types.d.ts

@@ -0,0 +1,11 @@
+import type { Node as PMNode, NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export type FormatNodeTargetType = 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'paragraph' | 'blockquote' | 'expand' | 'panel' | 'codeblock' | 'bulletList' | 'orderedList' | 'taskList';
+export interface TransformContext {
+    tr: Transaction;
+    sourceNode: PMNode;
+    sourcePos: number | null;
+    targetNodeType: NodeType;
+    targetAttrs?: Record<string, unknown>;
+}
+export type TransformFunction = (context: TransformContext) => Transaction | null;

package/dist/types/editor-commands/transforms/utils.d.ts

@@ -0,0 +1,12 @@
+import type { Node as PMNode, NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { FormatNodeTargetType } from './types';
+export declare const getTargetNodeInfo: (targetType: FormatNodeTargetType, nodes: Record<string, NodeType>) => {
+    nodeType: NodeType;
+    attrs?: Record<string, unknown>;
+} | null;
+export declare const isBlockNode: (node: PMNode) => boolean;
+export declare const isListNode: (node: PMNode) => boolean;
+export declare const isContainerNode: (node: PMNode) => boolean;
+export declare const isBlockNodeType: (nodeType: NodeType) => boolean;
+export declare const isListNodeType: (nodeType: NodeType) => boolean;
+export declare const isContainerNodeType: (nodeType: NodeType) => boolean;