@atlaskit/editor-plugin-block-type 16.1.29 → 16.1.30

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-plugin-block-type
 
+## 16.1.30
+
+### Patch Changes
+
+- [`bed6e0c408de8`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/bed6e0c408de8) -
+  [ux] Fix: pressing Enter after a heading that has trailing whitespace now creates a paragraph
+  instead of another heading — but only when the caret sits after all heading content and
+  immediately before the trailing whitespace (so it looks like the end of the heading). Mid-heading
+  splits still produce a heading. Behind the `platform_editor_fix_new_line_after_heading`
+  experiment.
+- Updated dependencies
+
 ## 16.1.29
 
 ### Patch Changes

package/dist/cjs/pm-plugins/commands/split-heading-with-trailing-space.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.splitHeadingWithTrailingSpace = void 0;
+var _commands = require("@atlaskit/editor-prosemirror/commands");
+// eslint-disable-next-line require-unicode-regexp
+var WHITESPACE_ONLY = /^\s+$/;
+
+/**
+ * Determines whether the current selection is inside a heading, positioned after
+ * all of the heading's visible (non-whitespace) content but *before* one or more
+ * trailing whitespace characters.
+ *
+ * In this scenario ProseMirror's default `splitBlock` treats the cursor as *not*
+ * being at the end of the node (`atEnd === false`), because there is still
+ * (whitespace) content between the cursor and the node boundary. As a result the
+ * newly split-off block inherits the heading type instead of becoming a
+ * paragraph — even though, visually, the cursor looks like it is at the end of
+ * the heading.
+ *
+ * We intentionally scope this to *only* that case:
+ * - The parent must be a heading.
+ * - The selection must be empty (a plain caret, not a range).
+ * - There must be at least one character between the caret and the end of the
+ *   heading, and every such character must be whitespace.
+ *
+ * All other cases (caret mid-word, caret at the true end, empty heading, etc.)
+ * return `false` so the default behaviour is preserved.
+ */
+var isCursorAfterHeadingContentBeforeTrailingWhitespace = function isCursorAfterHeadingContentBeforeTrailingWhitespace($from) {
+  var parent = $from.parent;
+  var headingType = $from.doc.type.schema.nodes.heading;
+  if (!headingType || parent.type !== headingType) {
+    return false;
+  }
+
+  // Offset of the caret within the heading's content.
+  var offsetInParent = $from.parentOffset;
+  var contentSize = parent.content.size;
+
+  // If the caret is already at (or past) the end of the heading content, this is
+  // the normal "atEnd" case handled correctly by the default split — skip.
+  if (offsetInParent >= contentSize) {
+    return false;
+  }
+
+  // The remaining text between the caret and the end of the heading.
+  var trailingText = parent.textBetween(offsetInParent, contentSize);
+
+  // Must be non-empty and consist solely of whitespace.
+  return trailingText.length > 0 && WHITESPACE_ONLY.test(trailingText);
+};
+
+/**
+ * A plain-Enter command that fixes the "new line after a heading with a trailing
+ * space becomes another heading" bug.
+ *
+ * It reuses ProseMirror's `splitBlockAs` but supplies a custom `splitNode`
+ * callback that forces the newly split-off block to be a paragraph *only* when
+ * the caret is in a heading, after all visible content, immediately before
+ * trailing whitespace. In every other case it returns `null`, which makes
+ * `splitBlockAs` fall back to its default type resolution — identical to the
+ * default `splitBlock` behaviour.
+ *
+ * The command returns `false` when the target scenario does not apply, allowing
+ * other Enter handlers (lists, code blocks, base keymap) to run unchanged.
+ */
+var splitHeadingWithTrailingSpace = exports.splitHeadingWithTrailingSpace = function splitHeadingWithTrailingSpace(state, dispatch, view) {
+  var $from = state.selection.$from;
+
+  // Only act on an empty caret selection inside a matching heading.
+  if (!state.selection.empty || !isCursorAfterHeadingContentBeforeTrailingWhitespace($from)) {
+    return false;
+  }
+  var paragraphType = state.schema.nodes.paragraph;
+  if (!paragraphType) {
+    return false;
+  }
+  return (0, _commands.splitBlockAs)(function (_node, atEnd) {
+    // Guard again inside the callback: only override the type for the exact
+    // scenario. If ProseMirror already considers us at the end, defer to the
+    // default (return null).
+    if (atEnd) {
+      return null;
+    }
+    return {
+      type: paragraphType
+    };
+  })(state, dispatch, view);
+};

package/dist/cjs/pm-plugins/keymap.js

@@ -10,10 +10,12 @@ var _keymaps = require("@atlaskit/editor-common/keymaps");
 var _utils = require("@atlaskit/editor-common/utils");
 var _commands = require("@atlaskit/editor-prosemirror/commands");
 var _prosemirrorHistory = require("@atlaskit/prosemirror-history");
+var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var blockTypes = _interopRequireWildcard(require("./block-types"));
 var _blockType = require("./commands/block-type");
 var _deleteAndMoveCursor = require("./commands/delete-and-move-cursor");
 var _deleteBlockContent = require("./commands/delete-block-content");
+var _splitHeadingWithTrailingSpace = require("./commands/split-heading-with-trailing-space");
 var _utils2 = require("./utils");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 // Ignored via go/ees005
@@ -27,6 +29,15 @@ function keymapPlugin(editorAnalyticsApi, schema, _featureFlags) {
   // Ignored via go/ees005
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   _keymaps.insertNewLine.common, (0, _utils.insertNewLineWithAnalytics)(editorAnalyticsApi), list);
+
+  // Fixes the "Enter after a heading with trailing whitespace creates another
+  // heading instead of a paragraph" bug. The command is a no-op (returns false)
+  // in every case except that exact scenario, so other Enter handlers are
+  // unaffected.
+  if ((0, _expValEquals.expValEquals)('platform_editor_fix_new_line_after_heading', 'isEnabled', true)) {
+    var _enter$common;
+    (0, _keymaps.bindKeymapWithCommand)((_enter$common = _keymaps.enter.common) !== null && _enter$common !== void 0 ? _enter$common : 'Enter', _splitHeadingWithTrailingSpace.splitHeadingWithTrailingSpace, list);
+  }
   // Ignored via go/ees005
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   (0, _keymaps.bindKeymapWithCommand)(_keymaps.moveUp.common, _utils.createNewParagraphAbove, list);

package/dist/es2019/pm-plugins/commands/split-heading-with-trailing-space.js

@@ -0,0 +1,88 @@
+import { splitBlockAs } from '@atlaskit/editor-prosemirror/commands';
+// eslint-disable-next-line require-unicode-regexp
+const WHITESPACE_ONLY = /^\s+$/;
+
+/**
+ * Determines whether the current selection is inside a heading, positioned after
+ * all of the heading's visible (non-whitespace) content but *before* one or more
+ * trailing whitespace characters.
+ *
+ * In this scenario ProseMirror's default `splitBlock` treats the cursor as *not*
+ * being at the end of the node (`atEnd === false`), because there is still
+ * (whitespace) content between the cursor and the node boundary. As a result the
+ * newly split-off block inherits the heading type instead of becoming a
+ * paragraph — even though, visually, the cursor looks like it is at the end of
+ * the heading.
+ *
+ * We intentionally scope this to *only* that case:
+ * - The parent must be a heading.
+ * - The selection must be empty (a plain caret, not a range).
+ * - There must be at least one character between the caret and the end of the
+ *   heading, and every such character must be whitespace.
+ *
+ * All other cases (caret mid-word, caret at the true end, empty heading, etc.)
+ * return `false` so the default behaviour is preserved.
+ */
+const isCursorAfterHeadingContentBeforeTrailingWhitespace = $from => {
+  const parent = $from.parent;
+  const headingType = $from.doc.type.schema.nodes.heading;
+  if (!headingType || parent.type !== headingType) {
+    return false;
+  }
+
+  // Offset of the caret within the heading's content.
+  const offsetInParent = $from.parentOffset;
+  const contentSize = parent.content.size;
+
+  // If the caret is already at (or past) the end of the heading content, this is
+  // the normal "atEnd" case handled correctly by the default split — skip.
+  if (offsetInParent >= contentSize) {
+    return false;
+  }
+
+  // The remaining text between the caret and the end of the heading.
+  const trailingText = parent.textBetween(offsetInParent, contentSize);
+
+  // Must be non-empty and consist solely of whitespace.
+  return trailingText.length > 0 && WHITESPACE_ONLY.test(trailingText);
+};
+
+/**
+ * A plain-Enter command that fixes the "new line after a heading with a trailing
+ * space becomes another heading" bug.
+ *
+ * It reuses ProseMirror's `splitBlockAs` but supplies a custom `splitNode`
+ * callback that forces the newly split-off block to be a paragraph *only* when
+ * the caret is in a heading, after all visible content, immediately before
+ * trailing whitespace. In every other case it returns `null`, which makes
+ * `splitBlockAs` fall back to its default type resolution — identical to the
+ * default `splitBlock` behaviour.
+ *
+ * The command returns `false` when the target scenario does not apply, allowing
+ * other Enter handlers (lists, code blocks, base keymap) to run unchanged.
+ */
+export const splitHeadingWithTrailingSpace = (state, dispatch, view) => {
+  const {
+    $from
+  } = state.selection;
+
+  // Only act on an empty caret selection inside a matching heading.
+  if (!state.selection.empty || !isCursorAfterHeadingContentBeforeTrailingWhitespace($from)) {
+    return false;
+  }
+  const paragraphType = state.schema.nodes.paragraph;
+  if (!paragraphType) {
+    return false;
+  }
+  return splitBlockAs((_node, atEnd) => {
+    // Guard again inside the callback: only override the type for the exact
+    // scenario. If ProseMirror already considers us at the end, defer to the
+    // default (return null).
+    if (atEnd) {
+      return null;
+    }
+    return {
+      type: paragraphType
+    };
+  })(state, dispatch, view);
+};

package/dist/es2019/pm-plugins/keymap.js

@@ -1,8 +1,9 @@
 import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { backspace, bindKeymapWithCommand, deleteKey, findKeyMapForBrowser, findShortcutByKeymap, forwardDelete, insertNewLine, keymap, moveDown, moveUp, redo as redoKeymap, toggleBlockQuote, undo as undoKeymap } from '@atlaskit/editor-common/keymaps';
+import { backspace, bindKeymapWithCommand, deleteKey, enter, findKeyMapForBrowser, findShortcutByKeymap, forwardDelete, insertNewLine, keymap, moveDown, moveUp, redo as redoKeymap, toggleBlockQuote, undo as undoKeymap } from '@atlaskit/editor-common/keymaps';
 import { createNewParagraphAbove, createNewParagraphBelow, deleteEmptyParagraphAndMoveBlockUp, insertNewLineWithAnalytics } from '@atlaskit/editor-common/utils';
 import { chainCommands } from '@atlaskit/editor-prosemirror/commands';
 import { redo, undo } from '@atlaskit/prosemirror-history';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 
 // Ignored via go/ees005
 // eslint-disable-next-line import/no-namespace
@@ -10,6 +11,7 @@ import * as blockTypes from './block-types';
 import { cleanUpAtTheStartOfDocument, insertBlockQuoteWithAnalytics } from './commands/block-type';
 import { deleteAndMoveCursor } from './commands/delete-and-move-cursor';
 import { deleteBlockContent } from './commands/delete-block-content';
+import { splitHeadingWithTrailingSpace } from './commands/split-heading-with-trailing-space';
 import { isNodeAWrappingBlockNode } from './utils';
 const backspaceCommand = chainCommands(cleanUpAtTheStartOfDocument, deleteBlockContent(isNodeAWrappingBlockNode), deleteAndMoveCursor);
 const del = chainCommands(deleteEmptyParagraphAndMoveBlockUp(isNodeAWrappingBlockNode), deleteBlockContent(isNodeAWrappingBlockNode), deleteAndMoveCursor);
@@ -19,6 +21,15 @@ export default function keymapPlugin(editorAnalyticsApi, schema, _featureFlags)
   // Ignored via go/ees005
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   insertNewLine.common, insertNewLineWithAnalytics(editorAnalyticsApi), list);
+
+  // Fixes the "Enter after a heading with trailing whitespace creates another
+  // heading instead of a paragraph" bug. The command is a no-op (returns false)
+  // in every case except that exact scenario, so other Enter handlers are
+  // unaffected.
+  if (expValEquals('platform_editor_fix_new_line_after_heading', 'isEnabled', true)) {
+    var _enter$common;
+    bindKeymapWithCommand((_enter$common = enter.common) !== null && _enter$common !== void 0 ? _enter$common : 'Enter', splitHeadingWithTrailingSpace, list);
+  }
   // Ignored via go/ees005
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   bindKeymapWithCommand(moveUp.common, createNewParagraphAbove, list);

package/dist/esm/pm-plugins/commands/split-heading-with-trailing-space.js

@@ -0,0 +1,86 @@
+import { splitBlockAs } from '@atlaskit/editor-prosemirror/commands';
+// eslint-disable-next-line require-unicode-regexp
+var WHITESPACE_ONLY = /^\s+$/;
+
+/**
+ * Determines whether the current selection is inside a heading, positioned after
+ * all of the heading's visible (non-whitespace) content but *before* one or more
+ * trailing whitespace characters.
+ *
+ * In this scenario ProseMirror's default `splitBlock` treats the cursor as *not*
+ * being at the end of the node (`atEnd === false`), because there is still
+ * (whitespace) content between the cursor and the node boundary. As a result the
+ * newly split-off block inherits the heading type instead of becoming a
+ * paragraph — even though, visually, the cursor looks like it is at the end of
+ * the heading.
+ *
+ * We intentionally scope this to *only* that case:
+ * - The parent must be a heading.
+ * - The selection must be empty (a plain caret, not a range).
+ * - There must be at least one character between the caret and the end of the
+ *   heading, and every such character must be whitespace.
+ *
+ * All other cases (caret mid-word, caret at the true end, empty heading, etc.)
+ * return `false` so the default behaviour is preserved.
+ */
+var isCursorAfterHeadingContentBeforeTrailingWhitespace = function isCursorAfterHeadingContentBeforeTrailingWhitespace($from) {
+  var parent = $from.parent;
+  var headingType = $from.doc.type.schema.nodes.heading;
+  if (!headingType || parent.type !== headingType) {
+    return false;
+  }
+
+  // Offset of the caret within the heading's content.
+  var offsetInParent = $from.parentOffset;
+  var contentSize = parent.content.size;
+
+  // If the caret is already at (or past) the end of the heading content, this is
+  // the normal "atEnd" case handled correctly by the default split — skip.
+  if (offsetInParent >= contentSize) {
+    return false;
+  }
+
+  // The remaining text between the caret and the end of the heading.
+  var trailingText = parent.textBetween(offsetInParent, contentSize);
+
+  // Must be non-empty and consist solely of whitespace.
+  return trailingText.length > 0 && WHITESPACE_ONLY.test(trailingText);
+};
+
+/**
+ * A plain-Enter command that fixes the "new line after a heading with a trailing
+ * space becomes another heading" bug.
+ *
+ * It reuses ProseMirror's `splitBlockAs` but supplies a custom `splitNode`
+ * callback that forces the newly split-off block to be a paragraph *only* when
+ * the caret is in a heading, after all visible content, immediately before
+ * trailing whitespace. In every other case it returns `null`, which makes
+ * `splitBlockAs` fall back to its default type resolution — identical to the
+ * default `splitBlock` behaviour.
+ *
+ * The command returns `false` when the target scenario does not apply, allowing
+ * other Enter handlers (lists, code blocks, base keymap) to run unchanged.
+ */
+export var splitHeadingWithTrailingSpace = function splitHeadingWithTrailingSpace(state, dispatch, view) {
+  var $from = state.selection.$from;
+
+  // Only act on an empty caret selection inside a matching heading.
+  if (!state.selection.empty || !isCursorAfterHeadingContentBeforeTrailingWhitespace($from)) {
+    return false;
+  }
+  var paragraphType = state.schema.nodes.paragraph;
+  if (!paragraphType) {
+    return false;
+  }
+  return splitBlockAs(function (_node, atEnd) {
+    // Guard again inside the callback: only override the type for the exact
+    // scenario. If ProseMirror already considers us at the end, defer to the
+    // default (return null).
+    if (atEnd) {
+      return null;
+    }
+    return {
+      type: paragraphType
+    };
+  })(state, dispatch, view);
+};

package/dist/esm/pm-plugins/keymap.js

@@ -1,8 +1,9 @@
 import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { backspace, bindKeymapWithCommand, deleteKey, findKeyMapForBrowser, findShortcutByKeymap, forwardDelete, insertNewLine, keymap, moveDown, moveUp, redo as redoKeymap, toggleBlockQuote, undo as undoKeymap } from '@atlaskit/editor-common/keymaps';
+import { backspace, bindKeymapWithCommand, deleteKey, enter, findKeyMapForBrowser, findShortcutByKeymap, forwardDelete, insertNewLine, keymap, moveDown, moveUp, redo as redoKeymap, toggleBlockQuote, undo as undoKeymap } from '@atlaskit/editor-common/keymaps';
 import { createNewParagraphAbove, createNewParagraphBelow, deleteEmptyParagraphAndMoveBlockUp, insertNewLineWithAnalytics } from '@atlaskit/editor-common/utils';
 import { chainCommands } from '@atlaskit/editor-prosemirror/commands';
 import { redo, undo } from '@atlaskit/prosemirror-history';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 
 // Ignored via go/ees005
 // eslint-disable-next-line import/no-namespace
@@ -10,6 +11,7 @@ import * as blockTypes from './block-types';
 import { cleanUpAtTheStartOfDocument, insertBlockQuoteWithAnalytics } from './commands/block-type';
 import { deleteAndMoveCursor } from './commands/delete-and-move-cursor';
 import { deleteBlockContent } from './commands/delete-block-content';
+import { splitHeadingWithTrailingSpace } from './commands/split-heading-with-trailing-space';
 import { isNodeAWrappingBlockNode } from './utils';
 var backspaceCommand = chainCommands(cleanUpAtTheStartOfDocument, deleteBlockContent(isNodeAWrappingBlockNode), deleteAndMoveCursor);
 var del = chainCommands(deleteEmptyParagraphAndMoveBlockUp(isNodeAWrappingBlockNode), deleteBlockContent(isNodeAWrappingBlockNode), deleteAndMoveCursor);
@@ -19,6 +21,15 @@ export default function keymapPlugin(editorAnalyticsApi, schema, _featureFlags)
   // Ignored via go/ees005
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   insertNewLine.common, insertNewLineWithAnalytics(editorAnalyticsApi), list);
+
+  // Fixes the "Enter after a heading with trailing whitespace creates another
+  // heading instead of a paragraph" bug. The command is a no-op (returns false)
+  // in every case except that exact scenario, so other Enter handlers are
+  // unaffected.
+  if (expValEquals('platform_editor_fix_new_line_after_heading', 'isEnabled', true)) {
+    var _enter$common;
+    bindKeymapWithCommand((_enter$common = enter.common) !== null && _enter$common !== void 0 ? _enter$common : 'Enter', splitHeadingWithTrailingSpace, list);
+  }
   // Ignored via go/ees005
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   bindKeymapWithCommand(moveUp.common, createNewParagraphAbove, list);

package/dist/types/pm-plugins/commands/split-heading-with-trailing-space.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from '@atlaskit/editor-common/types';
+/**
+ * A plain-Enter command that fixes the "new line after a heading with a trailing
+ * space becomes another heading" bug.
+ *
+ * It reuses ProseMirror's `splitBlockAs` but supplies a custom `splitNode`
+ * callback that forces the newly split-off block to be a paragraph *only* when
+ * the caret is in a heading, after all visible content, immediately before
+ * trailing whitespace. In every other case it returns `null`, which makes
+ * `splitBlockAs` fall back to its default type resolution — identical to the
+ * default `splitBlock` behaviour.
+ *
+ * The command returns `false` when the target scenario does not apply, allowing
+ * other Enter handlers (lists, code blocks, base keymap) to run unchanged.
+ */
+export declare const splitHeadingWithTrailingSpace: Command;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-block-type",
-	"version": "16.1.29",
+	"version": "16.1.30",
 	"description": "BlockType plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -42,7 +42,7 @@
 		"@atlaskit/primitives": "^22.2.0",
 		"@atlaskit/prosemirror-history": "^1.0.0",
 		"@atlaskit/prosemirror-input-rules": "^4.0.0",
-		"@atlaskit/tmp-editor-statsig": "^133.0.0",
+		"@atlaskit/tmp-editor-statsig": "^133.1.0",
 		"@atlaskit/tokens": "^16.3.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^1.0.0",