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

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

@@ -0,0 +1,103 @@
+export const 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 const isBlockNode = node => {
+  return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
+};
+export const isListNode = node => {
+  return ['bulletList', 'orderedList', 'taskList', 'listItem'].includes(node.type.name);
+};
+export const isContainerNode = node => {
+  return ['panel', 'expand', 'blockquote'].includes(node.type.name);
+};
+export const isBlockNodeType = nodeType => {
+  return ['paragraph', 'heading', 'codeBlock'].includes(nodeType.name);
+};
+export const isListNodeType = nodeType => {
+  return ['bulletList', 'orderedList', 'taskList'].includes(nodeType.name);
+};
+export const isContainerNodeType = nodeType => {
+  return ['panel', 'expand', 'blockquote'].includes(nodeType.name);
+};

package/dist/esm/blockMenuPlugin.js

@@ -1,5 +1,6 @@
 import React from 'react';
 import { createBlockMenuRegistry } from './editor-actions';
+import { formatNode as _formatNode } from './editor-commands/formatNode';
 import { createPlugin } from './pm-plugins/main';
 import BlockMenu from './ui/block-menu';
 import { getBlockMenuComponents } from './ui/block-menu-components';
@@ -27,6 +28,11 @@ export var blockMenuPlugin = function blockMenuPlugin(_ref) {
         return registry.components;
       }
     },
+    commands: {
+      formatNode: function formatNode(currentNode, targetType) {
+        return _formatNode(currentNode, targetType);
+      }
+    },
     contentComponent: function contentComponent(_ref2) {
       var editorView = _ref2.editorView,
         popupsMountPoint = _ref2.popupsMountPoint,

package/dist/esm/editor-commands/formatNode.js

@@ -0,0 +1,17 @@
+import { transformNodeToTargetType } from './transforms/transformNodeToTargetType';
+/**
+ * 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 var formatNode = function formatNode(currentNode, targetType) {
+  return function (_ref) {
+    var tr = _ref.tr;
+    var selection = tr.selection;
+    try {
+      return transformNodeToTargetType(tr, currentNode, selection.from, targetType);
+    } catch (e) {
+      return null;
+    }
+  };
+};

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

@@ -0,0 +1,32 @@
+import { transformToContainer } from './container-transforms';
+import { transformToList } from './list-transforms';
+import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
+
+/**
+ * Transform block nodes (paragraph, heading, codeblock)
+ */
+export var transformBlockNode = function transformBlockNode(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  var selection = tr.selection;
+  var $from = selection.$from,
+    $to = selection.$to;
+
+  // Handle transformation to list types
+  if (isListNodeType(targetNodeType)) {
+    return transformToList();
+  }
+
+  // Handle transformation to container types (panel, expand, blockquote)
+  if (isContainerNodeType(targetNodeType)) {
+    return transformToContainer();
+  }
+
+  // Handle block type transformation (paragraph, heading, codeblock)
+  if (isBlockNodeType(targetNodeType)) {
+    tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
+    return tr;
+  }
+  return null;
+};

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/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>,

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;

package/dist/types-ts4.5/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>,

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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;