@atlaskit/editor-plugin-block-menu 9.0.19 → 9.1.1

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

@@ -1,155 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { transformBetweenListTypes, isTaskList } from '@atlaskit/editor-common/transforms';
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
-import { transformOrderedUnorderedListToBlockNodes } from './list/transformOrderedUnorderedListToBlockNodes';
-import { transformTaskListToBlockNodes } from './list/transformTaskListToBlockNodes';
-import { transformToTaskList } from './list/transformToTaskList';
-import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
-
-/**
- * Transform selection to list type
- */
-export var transformBlockToList = function transformBlockToList(context) {
-  var tr = context.tr,
-    sourceNode = context.sourceNode,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs;
-  var _tr$selection = tr.selection,
-    $from = _tr$selection.$from,
-    $to = _tr$selection.$to;
-  var schema = tr.doc.type.schema;
-  var range = $from.blockRange($to);
-  if (!range) {
-    return null;
-  }
-  var nodes = tr.doc.type.schema.nodes;
-  var isTargetTask = isTaskList(targetNodeType);
-
-  // Handle task lists differently due to their structure
-  if (isTargetTask) {
-    return transformToTaskList(tr, range, targetNodeType, targetAttrs, nodes);
-  }
-
-  // filter marks that are not allowed in the target node type
-  if (sourceNode.type === schema.nodes.paragraph || sourceNode.type === schema.nodes.heading) {
-    var allowedMarks = targetNodeType.allowedMarks(sourceNode.marks);
-    tr.setNodeMarkup(range.start, null, null, allowedMarks);
-  }
-
-  // For headings, convert to paragraph first since headings cannot be direct children of list items
-  if (sourceNode && sourceNode.type.name.startsWith('heading')) {
-    tr.setBlockType(range.start, range.end, nodes.paragraph);
-  }
-
-  // Get the current range (updated if we converted from heading)
-  var currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
-
-  // Wrap in the target list type
-  var wrapping = findWrapping(currentRange, targetNodeType, targetAttrs);
-  if (!wrapping) {
-    return null;
-  }
-  tr.wrap(currentRange, wrapping);
-  return tr;
-};
-
-/**
- * Transform list to block nodes
- */
-export var transformListToBlockNodes = function transformListToBlockNodes(context) {
-  var sourceNode = context.sourceNode;
-  if (sourceNode.type.name === 'taskList') {
-    return transformTaskListToBlockNodes(context);
-  } else {
-    return transformOrderedUnorderedListToBlockNodes(context);
-  }
-};
-
-/**
- * Wraps bulletList, orderedList or taskList in node of container type
- */
-export var transformListToContainer = function transformListToContainer(context) {
-  var tr = context.tr,
-    sourceNode = context.sourceNode,
-    sourcePos = context.sourcePos,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs;
-  if (sourcePos === null) {
-    return null;
-  }
-  var schema = tr.doc.type.schema;
-  var _schema$nodes = schema.nodes,
-    blockquote = _schema$nodes.blockquote,
-    taskList = _schema$nodes.taskList,
-    taskItem = _schema$nodes.taskItem,
-    paragraph = _schema$nodes.paragraph;
-
-  // Special case: Task list -> Blockquote
-  // Flattens the task list before wrapping by blockquote
-  if (sourceNode.type === taskList && targetNodeType === blockquote) {
-    var _extractParagraphsFromTaskList = function extractParagraphsFromTaskList(node) {
-      var paragraphs = [];
-      node.forEach(function (child) {
-        if (child.type === taskItem) {
-          if (child.content.size > 0) {
-            var paragraphNode = paragraph.createChecked({}, child.content.content);
-            paragraphs.push(paragraphNode);
-          }
-        } else if (child.type === taskList) {
-          paragraphs.push.apply(paragraphs, _toConsumableArray(_extractParagraphsFromTaskList(child)));
-        }
-      });
-      return paragraphs;
-    };
-    var liftedParagraphs = _extractParagraphsFromTaskList(sourceNode);
-    var _containerNode = targetNodeType.createAndFill(targetAttrs, Fragment.from(liftedParagraphs));
-    if (!_containerNode) {
-      return null;
-    }
-    tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, _containerNode);
-    return tr;
-  }
-
-  // Default case
-  var containerNode = targetNodeType.createAndFill(targetAttrs, [sourceNode]);
-  if (!containerNode) {
-    return null;
-  }
-  tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, containerNode);
-  return tr;
-};
-
-/**
- * Transform list nodes
- */
-export var transformListNode = function transformListNode(context) {
-  var targetNodeType = context.targetNodeType;
-  // Transform list to block type
-  if (isBlockNodeType(targetNodeType)) {
-    // Lift list items out of the list and convert to target block type
-    return transformListToBlockNodes(context);
-  }
-
-  // Transform list to container type
-  if (isContainerNodeType(targetNodeType)) {
-    // Wrap list items into container type, where possible
-    return transformListToContainer(context);
-  }
-
-  // Transform between list types
-  if (isListNodeType(targetNodeType)) {
-    return transformBetweenListTypes(context);
-  }
-  return null;
-};
-
-/**
- * Lift list content and convert to block type
- */
-export var liftListToBlockType = function liftListToBlockType() {
-  // Convert to target block type directly
-  return null;
-};
-
-// transformBetweenListTypes is now imported from @atlaskit/editor-common/transforms

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

@@ -1,72 +0,0 @@
-import { transformBlockNode } from './block-transforms';
-import { transformContainerNode, unwrapAndConvertToList } from './container-transforms';
-import { convertToLayout, transformLayoutNode } from './layout-transforms';
-import { transformListNode } from './list-transforms';
-import { getTargetNodeInfo, isBlockNode, isListNode, isListNodeType, isContainerNode, isLayoutNodeType, isLayoutNode } from './utils';
-
-/**
- * Transforms a source node to the specified target type.
- * Throws errors on failure which should be caught at the command level.
- *
- * @param tr - The transaction to apply transformations to
- * @param sourceNode - The node to transform
- * @param sourcePos - The position of the source node in the document
- * @param targetType - The target node type to transform to
- * @returns The modified transaction if successful, null if transformation is not possible
- */
-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.name === targetNodeType.name) {
-    // For headings, also check if the level matches
-    if (targetNodeType.name === 'heading') {
-      var _sourceNode$attrs;
-      var sourceLevel = (_sourceNode$attrs = sourceNode.attrs) === null || _sourceNode$attrs === void 0 ? void 0 : _sourceNode$attrs.level;
-      var targetLevel = targetAttrs === null || targetAttrs === void 0 ? void 0 : targetAttrs.level;
-      if (sourceLevel === targetLevel) {
-        return tr;
-      }
-    } else {
-      return tr;
-    }
-  }
-
-  // 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
-  if (isLayoutNodeType(targetNodeType)) {
-    return convertToLayout(transformationContext);
-  }
-
-  // special case codeblock to listType
-  if (sourceNode.type.name === 'codeBlock' && isListNodeType(targetNodeType)) {
-    return unwrapAndConvertToList(transformationContext);
-  }
-  if (isLayoutNode(sourceNode)) {
-    return transformLayoutNode(transformationContext);
-  }
-  if (isBlockNode(sourceNode)) {
-    return transformBlockNode(transformationContext);
-  }
-  if (isListNode(sourceNode)) {
-    return transformListNode(transformationContext);
-  }
-  if (isContainerNode(sourceNode)) {
-    return transformContainerNode(transformationContext);
-  }
-  return null;
-}

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

@@ -1,253 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { breakoutResizableNodes } from '@atlaskit/editor-common/utils';
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
-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
-      };
-    case 'layoutSection':
-      return {
-        nodeType: nodes.layoutSection
-      };
-    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 isHeadingOrParagraphNode = function isHeadingOrParagraphNode(node) {
-  return ['paragraph', 'heading'].includes(node.type.name);
-};
-export var isListNode = function isListNode(node) {
-  return ['bulletList', 'orderedList', 'taskList'].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);
-};
-
-// List type utilities moved to @atlaskit/editor-common/transforms
-
-export var isLayoutNodeType = function isLayoutNodeType(nodeType) {
-  return nodeType.name === 'layoutSection';
-};
-export var isLayoutNode = function isLayoutNode(node) {
-  return node.type.name === 'layoutSection';
-};
-
-/**
- * Check if a node should be extracted as a standalone block node
- * rather than converted to inline content
- */
-export var isBlockNodeForExtraction = function isBlockNodeForExtraction(node) {
-  var blockNodesForExtraction = ['table', 'mediaSingle', 'extension', 'bodiedExtension', 'blockCard', 'embedCard'];
-  return blockNodesForExtraction.includes(node.type.name);
-};
-
-/**
- * Get a function that checks if content is supported in the target container type
- */
-export var getContentSupportChecker = function getContentSupportChecker(targetNodeType) {
-  return function (node) {
-    // Check if the target container type can contain this node
-    try {
-      return targetNodeType.validContent(Fragment.from(node));
-    } catch (_unused) {
-      return false;
-    }
-  };
-};
-
-/**
- * Convert a node to inline content that can be placed in a paragraph
- */
-export var convertNodeToInlineContent = function convertNodeToInlineContent(node, schema) {
-  // Extract text and inline nodes from any complex node
-  var inlineNodes = [];
-  node.descendants(function (childNode) {
-    if (childNode.isText) {
-      inlineNodes.push(childNode);
-    } else if (childNode.isInline) {
-      inlineNodes.push(childNode);
-    }
-    return true; // Continue traversing
-  });
-
-  // If no inline content was found but the node has text content,
-  // create a text node with the full text content
-  if (inlineNodes.length === 0 && node.textContent) {
-    return [schema.text(node.textContent)];
-  }
-  return inlineNodes;
-};
-
-/**
- * Filter marks from content based on the target node type
- * @param content The content fragment to filter
- * @param targetNodeType The target node type to check against
- * @returns A new fragment with marks filtered for the target node type
- */
-export var filterMarksForTargetNodeType = function filterMarksForTargetNodeType(content, targetNodeType) {
-  var withValidMarks = [];
-  content.forEach(function (node) {
-    if (node.marks.length > 0) {
-      var allowedMarks = targetNodeType.allowedMarks(node.marks);
-      var updatedNode = node.mark(allowedMarks);
-      withValidMarks.push(updatedNode);
-    } else {
-      withValidMarks.push(node);
-    }
-  });
-  return Fragment.from(withValidMarks);
-};
-
-/** * Convert content from a code block node into multiple paragraph nodes
- */
-export var convertCodeBlockContentToParagraphs = function convertCodeBlockContentToParagraphs(codeBlockNode, schema) {
-  var paragraphNodes = [];
-  var codeText = codeBlockNode.textContent;
-  var lines = codeText.split('\n');
-  lines.forEach(function (line) {
-    var paragraphNode = schema.nodes.paragraph.create(null, line ? schema.text(line) : null);
-    paragraphNodes.push(paragraphNode);
-  });
-  return paragraphNodes;
-};
-var isBreakoutMarkSupported = function isBreakoutMarkSupported(nodeType) {
-  return editorExperiment('platform_synced_block', true) ? breakoutResizableNodes.includes(nodeType.name) : ['codeBlock', 'expand', 'layoutSection'].includes(nodeType.name);
-};
-export var getMarksWithBreakout = function getMarksWithBreakout(sourceNode, targetNodeType) {
-  var allowedMarks = targetNodeType.allowedMarks(sourceNode.marks);
-  var sourceBreakoutMark = sourceNode.marks.find(function (mark) {
-    return mark.type.name === 'breakout';
-  });
-  if (sourceBreakoutMark && isBreakoutMarkSupported(targetNodeType)) {
-    // Check if breakout mark is already in allowedMarks to avoid duplicates
-    var hasBreakoutMark = allowedMarks.some(function (mark) {
-      return mark.type.name === 'breakout';
-    });
-    return hasBreakoutMark ? allowedMarks : [].concat(_toConsumableArray(allowedMarks), [sourceBreakoutMark]);
-  }
-  return allowedMarks;
-};
-
-/**
- * Determines the conversion type based on source and target node types
- * This is for analytics use - these types match existing analytics events for consistency
- */
-export var getConversionType = function getConversionType(from, to) {
-  // Block node insertion: block-like elements inserted from empty line or wrapping text/list
-  var blockNodes = ['panel', 'expand', 'codeBlock', 'layoutSection', 'taskList'];
-  var textNodes = ['paragraph', 'blockquote'];
-  var headingNodes = ['heading1', 'heading2', 'heading3', 'heading4', 'heading5', 'heading6'];
-  var listNodes = ['bulletList', 'orderedList'];
-
-  // Check if converting to block nodes from text/heading/list nodes
-  if (blockNodes.includes(to) && (textNodes.includes(from) || headingNodes.includes(from) || listNodes.includes(from))) {
-    return 'blockNodeInserted';
-  }
-
-  // Check if converting from paragraph/blockquote to list
-  if (listNodes.includes(to) && textNodes.includes(from)) {
-    return 'listInserted';
-  }
-
-  // Check if converting from list to paragraph/heading/blockquote or between list types
-  if (listNodes.includes(from) && (listNodes.includes(to) || textNodes.includes(to))) {
-    return 'listConverted';
-  }
-
-  // Text formatting: conversions among paragraph/headings/blockquote
-  if ((textNodes.includes(from) || headingNodes.includes(from)) && (textNodes.includes(to) || headingNodes.includes(to))) {
-    return 'textFormatted';
-  }
-  // For other conversions, we do not have a matching event category
-  return undefined;
-};

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

@@ -1,5 +0,0 @@
-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

@@ -1,20 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-import type { TransformFunction } from './types';
-/**
- * Transform selection to container type
- */
-export declare const transformToContainer: ({ tr, sourceNode, targetNodeType, targetAttrs, }: TransformContext) => Transaction | 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: (context: TransformContext) => Transaction;
-/**
- * Unwrap container node and convert content to list
- */
-export declare const unwrapAndConvertToList: ({ tr, sourceNode, sourcePos, targetNodeType, targetAttrs, }: TransformContext) => Transaction | null;
-export declare const transformBetweenContainerTypes: (context: TransformContext) => Transaction;

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

@@ -1,6 +0,0 @@
-import type { Fragment, Schema, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-export declare const getInlineNodeTextContent: (sourceContent: Fragment) => {
-    inlineTextContent: string;
-    invalidContent: PMNode[];
-};
-export declare const getInlineNodeTextNode: (sourceContent: Fragment, schema: Schema) => PMNode;

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

@@ -1,5 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
-export declare const unwrapLayoutNodesToTextNodes: (context: TransformContext, finalTargetNodeType: NodeType) => PMNode[];
-export declare const transformToListNode: (nodes: PMNode[], targetNodeType: NodeType, schema: Schema) => PMNode[];
-export declare const convertUnwrappedLayoutContent: (nodes: PMNode[], targetNodeType: NodeType, schema: Schema, targetAttrs?: TransformContext["targetAttrs"]) => PMNode[];

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

@@ -1,6 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import { type Mark, type Node as PMNode, type Schema } from '@atlaskit/editor-prosemirror/model';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-export declare const createDefaultLayoutSection: (schema: Schema, content: PMNode, marks?: readonly Mark[]) => PMNode;
-export declare const convertToLayout: (context: TransformContext) => Transaction;
-export declare const transformLayoutNode: (context: TransformContext) => Transaction;

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

@@ -1,3 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-export declare const transformOrderedUnorderedListToBlockNodes: (context: TransformContext) => Transaction | null;

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

@@ -1,3 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-export declare const transformTaskListToBlockNodes: (context: TransformContext) => Transaction | null;

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

@@ -1,10 +0,0 @@
-import type { NodeType } from '@atlaskit/editor-prosemirror/model';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-/**
- * Transform selection to task list
- * Handles the special structure where taskItem contains text directly (no paragraph wrapper)
- */
-export declare const transformToTaskList: (tr: Transaction, range: {
-    end: number;
-    start: number;
-}, targetNodeType: NodeType, targetAttrs: Record<string, unknown> | undefined, nodes: Record<string, NodeType>) => Transaction | null;

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

@@ -1,23 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-import type { TransformFunction } from './types';
-/**
- * Transform selection to list type
- */
-export declare const transformBlockToList: (context: TransformContext) => Transaction | null;
-/**
- * Transform list to block nodes
- */
-export declare const transformListToBlockNodes: (context: TransformContext) => Transaction | null;
-/**
- * Wraps bulletList, orderedList or taskList in node of container type
- */
-export declare const transformListToContainer: (context: TransformContext) => Transaction | null;
-/**
- * Transform list nodes
- */
-export declare const transformListNode: TransformFunction;
-/**
- * Lift list content and convert to block type
- */
-export declare const liftListToBlockType: () => null;

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

@@ -1,14 +0,0 @@
-import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-import type { TransfromNodeTargetType } from './types';
-/**
- * Transforms a source node to the specified target type.
- * Throws errors on failure which should be caught at the command level.
- *
- * @param tr - The transaction to apply transformations to
- * @param sourceNode - The node to transform
- * @param sourcePos - The position of the source node in the document
- * @param targetType - The target node type to transform to
- * @returns The modified transaction if successful, null if transformation is not possible
- */
-export declare function transformNodeToTargetType(tr: Transaction, sourceNode: PMNode, sourcePos: number, targetType: TransfromNodeTargetType): Transaction | null;

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

@@ -1,45 +0,0 @@
-import type { Mark, Node as PMNode, NodeType, Schema } from '@atlaskit/editor-prosemirror/model';
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import type { TransfromNodeTargetType } from './types';
-export declare const getTargetNodeInfo: (targetType: TransfromNodeTargetType, nodes: Record<string, NodeType>) => {
-    attrs?: Record<string, unknown>;
-    nodeType: NodeType;
-} | null;
-export declare const isBlockNode: (node: PMNode) => boolean;
-export declare const isHeadingOrParagraphNode: (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;
-export declare const isLayoutNodeType: (nodeType: NodeType) => boolean;
-export declare const isLayoutNode: (node: PMNode) => boolean;
-/**
- * Check if a node should be extracted as a standalone block node
- * rather than converted to inline content
- */
-export declare const isBlockNodeForExtraction: (node: PMNode) => boolean;
-/**
- * Get a function that checks if content is supported in the target container type
- */
-export declare const getContentSupportChecker: (targetNodeType: NodeType) => ((node: PMNode) => boolean);
-/**
- * Convert a node to inline content that can be placed in a paragraph
- */
-export declare const convertNodeToInlineContent: (node: PMNode, schema: Schema) => PMNode[];
-/**
- * Filter marks from content based on the target node type
- * @param content The content fragment to filter
- * @param targetNodeType The target node type to check against
- * @returns A new fragment with marks filtered for the target node type
- */
-export declare const filterMarksForTargetNodeType: (content: Fragment, targetNodeType: NodeType) => Fragment;
-/** * Convert content from a code block node into multiple paragraph nodes
- */
-export declare const convertCodeBlockContentToParagraphs: (codeBlockNode: PMNode, schema: Schema) => PMNode[];
-export declare const getMarksWithBreakout: (sourceNode: PMNode, targetNodeType: NodeType) => readonly Mark[];
-/**
- * Determines the conversion type based on source and target node types
- * This is for analytics use - these types match existing analytics events for consistency
- */
-export declare const getConversionType: (from: string, to: string) => "blockNodeInserted" | "listInserted" | "listConverted" | "textFormatted" | undefined;

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

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

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

@@ -1,20 +0,0 @@
-import type { TransformContext } from '@atlaskit/editor-common/transforms';
-import type { Transaction } from '@atlaskit/editor-prosemirror/state';
-import type { TransformFunction } from './types';
-/**
- * Transform selection to container type
- */
-export declare const transformToContainer: ({ tr, sourceNode, targetNodeType, targetAttrs, }: TransformContext) => Transaction | 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: (context: TransformContext) => Transaction;
-/**
- * Unwrap container node and convert content to list
- */
-export declare const unwrapAndConvertToList: ({ tr, sourceNode, sourcePos, targetNodeType, targetAttrs, }: TransformContext) => Transaction | null;
-export declare const transformBetweenContainerTypes: (context: TransformContext) => Transaction;

package/dist/types-ts4.5/editor-commands/transforms/inline-node-transforms.d.ts

@@ -1,6 +0,0 @@
-import type { Fragment, Schema, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-export declare const getInlineNodeTextContent: (sourceContent: Fragment) => {
-    inlineTextContent: string;
-    invalidContent: PMNode[];
-};
-export declare const getInlineNodeTextNode: (sourceContent: Fragment, schema: Schema) => PMNode;