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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 0.0.13
 
 ### Patch Changes

package/dist/cjs/blockMenuPlugin.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.blockMenuPlugin = void 0;
 var _react = _interopRequireDefault(require("react"));
 var _editorActions = require("./editor-actions");
+var _formatNode2 = require("./editor-commands/formatNode");
 var _main = require("./pm-plugins/main");
 var _blockMenu = _interopRequireDefault(require("./ui/block-menu"));
 var _blockMenuComponents = require("./ui/block-menu-components");
@@ -34,6 +35,11 @@ var blockMenuPlugin = exports.blockMenuPlugin = function blockMenuPlugin(_ref) {
         return registry.components;
       }
     },
+    commands: {
+      formatNode: function formatNode(currentNode, targetType) {
+        return (0, _formatNode2.formatNode)(currentNode, targetType);
+      }
+    },
     contentComponent: function contentComponent(_ref2) {
       var editorView = _ref2.editorView,
         popupsMountPoint = _ref2.popupsMountPoint,

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatNode = void 0;
+var _transformNodeToTargetType = require("./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
+ */
+var formatNode = exports.formatNode = function formatNode(currentNode, targetType) {
+  return function (_ref) {
+    var tr = _ref.tr;
+    var selection = tr.selection;
+    try {
+      return (0, _transformNodeToTargetType.transformNodeToTargetType)(tr, currentNode, selection.from, targetType);
+    } catch (e) {
+      return null;
+    }
+  };
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformBlockNode = void 0;
+var _containerTransforms = require("./container-transforms");
+var _listTransforms = require("./list-transforms");
+var _utils = require("./utils");
+/**
+ * Transform block nodes (paragraph, heading, codeblock)
+ */
+var transformBlockNode = exports.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 ((0, _utils.isListNodeType)(targetNodeType)) {
+    return (0, _listTransforms.transformToList)();
+  }
+
+  // Handle transformation to container types (panel, expand, blockquote)
+  if ((0, _utils.isContainerNodeType)(targetNodeType)) {
+    return (0, _containerTransforms.transformToContainer)();
+  }
+
+  // Handle block type transformation (paragraph, heading, codeblock)
+  if ((0, _utils.isBlockNodeType)(targetNodeType)) {
+    tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
+    return tr;
+  }
+  return null;
+};

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

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unwrapAndConvertToList = exports.unwrapAndConvertToBlockType = exports.transformToContainer = exports.transformContainerNode = void 0;
+var _utils = require("./utils");
+/**
+ * Transform selection to container type
+ */
+var transformToContainer = exports.transformToContainer = function transformToContainer() {
+  return null;
+};
+
+/**
+ * Transform container nodes (panel, expand, blockquote)
+ */
+var transformContainerNode = exports.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 ((0, _utils.isBlockNodeType)(targetNodeType)) {
+    return unwrapAndConvertToBlockType();
+  }
+
+  // Transform container to list type
+  if ((0, _utils.isListNodeType)(targetNodeType)) {
+    return unwrapAndConvertToList();
+  }
+
+  // Transform between container types
+  if ((0, _utils.isContainerNodeType)(targetNodeType)) {
+    tr.setNodeMarkup(sourcePos, targetNodeType, targetAttrs);
+    return tr;
+  }
+  return null;
+};
+
+/**
+ * Unwrap container node and convert content to block type
+ */
+var unwrapAndConvertToBlockType = exports.unwrapAndConvertToBlockType = function unwrapAndConvertToBlockType() {
+  // Convert to block type directly
+  return null;
+};
+
+/**
+ * Unwrap container node and convert content to list
+ */
+var unwrapAndConvertToList = exports.unwrapAndConvertToList = function unwrapAndConvertToList() {
+  // Convert to list directly
+  return null;
+};

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

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformToList = exports.transformListNode = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
+var _utils = require("./utils");
+/**
+ * Transform selection to list type
+ */
+var transformToList = exports.transformToList = function transformToList() {
+  return null;
+};
+
+/**
+ * Transform list nodes
+ */
+var transformListNode = exports.transformListNode = function transformListNode(_ref) {
+  var targetNodeType = _ref.targetNodeType;
+  // Transform list to block type
+  if ((0, _utils.isBlockNodeType)(targetNodeType)) {
+    // Lift list items out of the list and convert to target block type
+    return null;
+  }
+
+  // Transform list to container type
+  if ((0, _utils.isContainerNodeType)(targetNodeType)) {
+    // Lift list items out of the list and convert to container type
+    return null;
+  }
+
+  // Transform between list types
+  if ((0, _utils.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
+ */
+var liftListToBlockType = exports.liftListToBlockType = function liftListToBlockType() {
+  // Convert to target block type directly
+  return null;
+};
+
+/**
+ * Transform between different list types
+ */
+var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes() {
+  return null;
+};

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformNodeToTargetType = transformNodeToTargetType;
+var _blockTransforms = require("./block-transforms");
+var _containerTransforms = require("./container-transforms");
+var _listTransforms = require("./list-transforms");
+var _utils = require("./utils");
+function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
+  var nodes = tr.doc.type.schema.nodes;
+  var targetNodeInfo = (0, _utils.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 ((0, _utils.isBlockNode)(sourceNode)) {
+      return (0, _blockTransforms.transformBlockNode)(transformationContext);
+    }
+    if ((0, _utils.isListNode)(sourceNode)) {
+      return (0, _listTransforms.transformListNode)(transformationContext);
+    }
+    if ((0, _utils.isContainerNode)(sourceNode)) {
+      return (0, _containerTransforms.transformContainerNode)(transformationContext);
+    }
+    return null;
+  } catch (e) {
+    // Node transformation failed
+    return null;
+  }
+}

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isListNodeType = exports.isListNode = exports.isContainerNodeType = exports.isContainerNode = exports.isBlockNodeType = exports.isBlockNode = exports.getTargetNodeInfo = void 0;
+var getTargetNodeInfo = exports.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
+var isBlockNode = exports.isBlockNode = function isBlockNode(node) {
+  return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
+};
+var isListNode = exports.isListNode = function isListNode(node) {
+  return ['bulletList', 'orderedList', 'taskList', 'listItem'].includes(node.type.name);
+};
+var isContainerNode = exports.isContainerNode = function isContainerNode(node) {
+  return ['panel', 'expand', 'blockquote'].includes(node.type.name);
+};
+var isBlockNodeType = exports.isBlockNodeType = function isBlockNodeType(nodeType) {
+  return ['paragraph', 'heading', 'codeBlock'].includes(nodeType.name);
+};
+var isListNodeType = exports.isListNodeType = function isListNodeType(nodeType) {
+  return ['bulletList', 'orderedList', 'taskList'].includes(nodeType.name);
+};
+var isContainerNodeType = exports.isContainerNodeType = function isContainerNodeType(nodeType) {
+  return ['panel', 'expand', 'blockquote'].includes(nodeType.name);
+};

package/dist/es2019/blockMenuPlugin.js

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

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

@@ -0,0 +1,20 @@
+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 const formatNode = (currentNode, targetType) => {
+  return ({
+    tr
+  }) => {
+    const {
+      selection
+    } = tr;
+    try {
+      return transformNodeToTargetType(tr, currentNode, selection.from, targetType);
+    } catch (e) {
+      return null;
+    }
+  };
+};

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

@@ -0,0 +1,38 @@
+import { transformToContainer } from './container-transforms';
+import { transformToList } from './list-transforms';
+import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
+
+/**
+ * Transform block nodes (paragraph, heading, codeblock)
+ */
+export const transformBlockNode = context => {
+  const {
+    tr,
+    targetNodeType,
+    targetAttrs
+  } = context;
+  const {
+    selection
+  } = tr;
+  const {
+    $from,
+    $to
+  } = selection;
+
+  // 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/es2019/editor-commands/transforms/container-transforms.js

@@ -0,0 +1,55 @@
+import { isBlockNodeType, isListNodeType, isContainerNodeType } from './utils';
+
+/**
+ * Transform selection to container type
+ */
+export const transformToContainer = () => {
+  return null;
+};
+
+/**
+ * Transform container nodes (panel, expand, blockquote)
+ */
+export const transformContainerNode = ({
+  tr,
+  sourcePos,
+  targetNodeType,
+  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 const unwrapAndConvertToBlockType = () => {
+  // Convert to block type directly
+  return null;
+};
+
+/**
+ * Unwrap container node and convert content to list
+ */
+export const unwrapAndConvertToList = () => {
+  // Convert to list directly
+  return null;
+};

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

@@ -0,0 +1,49 @@
+import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
+
+/**
+ * Transform selection to list type
+ */
+export const transformToList = () => {
+  return null;
+};
+
+/**
+ * Transform list nodes
+ */
+export const transformListNode = ({
+  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 const liftListToBlockType = () => {
+  // Convert to target block type directly
+  return null;
+};
+
+/**
+ * Transform between different list types
+ */
+export const transformBetweenListTypes = () => {
+  return null;
+};

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

@@ -0,0 +1,48 @@
+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) {
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  const targetNodeInfo = getTargetNodeInfo(targetType, nodes);
+  if (!targetNodeInfo) {
+    return null;
+  }
+  const {
+    nodeType: targetNodeType,
+    attrs: targetAttrs
+  } = targetNodeInfo;
+
+  // Early return if trying to transform to the same type
+  if (sourceNode.type === targetNodeType) {
+    return tr; // No transformation needed
+  }
+
+  // Prepare transformation context
+  const transformationContext = {
+    tr,
+    sourceNode,
+    sourcePos,
+    targetNodeType,
+    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/es2019/editor-commands/transforms/types.js

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