@atlaskit/editor-common 110.49.2 → 110.50.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-common
 
+## 110.50.0
+
+### Minor Changes
+
+- [`909bd527e4564`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/909bd527e4564) -
+  Introduce a new createADFFromHTML function for use with the placeholder options.
+
+### Patch Changes
+
+- [`fd5c8dd25d59a`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/fd5c8dd25d59a) -
+  [ux] [ENGHEALTH-47470] remove redundant aria-label from ErrorIcon
+
 ## 110.49.2
 
 ### Patch Changes

package/dist/cjs/messages/index.js

@@ -451,5 +451,15 @@ var _default = exports.default = (0, _reactIntlNext.defineMessages)({
     id: 'fabric.editor.imageEdit',
     defaultMessage: 'Edit image',
     description: 'Crop, flip or rotate the image'
+  },
+  error: {
+    id: 'fabric.editor.error.message.label',
+    defaultMessage: 'Error',
+    description: 'Label for error message icon'
+  },
+  success: {
+    id: 'fabric.editor.success.message.label',
+    defaultMessage: 'Success',
+    description: 'Label for success message icon'
   }
 });

package/dist/cjs/monitoring/error.js

@@ -19,7 +19,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 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); }
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "110.49.1";
+var packageVersion = "110.49.2";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/cjs/ui/DropList/index.js

@@ -24,7 +24,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
  * @jsx jsx
  */ // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "110.49.1";
+var packageVersion = "110.49.2";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = (0, _react2.keyframes)({

package/dist/cjs/ui/Messages/index.js

@@ -6,8 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ValidMessage = exports.HelperMessage = exports.ErrorMessage = void 0;
 var _react = require("@emotion/react");
+var _reactIntlNext = require("react-intl-next");
 var _statusError = _interopRequireDefault(require("@atlaskit/icon/core/status-error"));
 var _statusSuccess = _interopRequireDefault(require("@atlaskit/icon/core/status-success"));
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _messages = _interopRequireDefault(require("../../messages"));
 /**
  * @jsxRuntime classic
  * @jsx jsx
@@ -52,13 +55,18 @@ var HelperMessage = exports.HelperMessage = function HelperMessage(_ref) {
 };
 var ErrorMessage = exports.ErrorMessage = function ErrorMessage(_ref2) {
   var children = _ref2.children;
+  var intl = (0, _reactIntlNext.useIntl)();
   return (0, _react.jsx)("div", {
     css: function css() {
       return [messageStyle(), errorColor];
     }
   }, (0, _react.jsx)("span", {
     css: iconWrapperStyle
-  }, (0, _react.jsx)(_statusError.default, {
+  }, (0, _platformFeatureFlags.fg)('platform_editor_dec_a11y_fixes') ? (0, _react.jsx)(_statusError.default, {
+    LEGACY_size: "small",
+    label: intl.formatMessage(_messages.default.error)
+  })
+  /* eslint-disable-next-line @atlassian/i18n/no-literal-string-in-jsx */ : (0, _react.jsx)(_statusError.default, {
     LEGACY_size: "small",
     label: "error",
     "aria-label": "error"
@@ -66,13 +74,17 @@ var ErrorMessage = exports.ErrorMessage = function ErrorMessage(_ref2) {
 };
 var ValidMessage = exports.ValidMessage = function ValidMessage(_ref3) {
   var children = _ref3.children;
+  var intl = (0, _reactIntlNext.useIntl)();
   return (0, _react.jsx)("div", {
     css: function css() {
       return [messageStyle(), validColor];
     }
   }, (0, _react.jsx)("span", {
     css: iconWrapperStyle
-  }, (0, _react.jsx)(_statusSuccess.default, {
+  }, (0, _platformFeatureFlags.fg)('platform_editor_dec_a11y_fixes') ? (0, _react.jsx)(_statusSuccess.default, {
+    LEGACY_size: "small",
+    label: intl.formatMessage(_messages.default.success)
+  }) : (0, _react.jsx)(_statusSuccess.default, {
     LEGACY_size: "small",
     label: "success"
   })), children);

package/dist/cjs/utils/create-adf-from-html.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createADFFromHTML = void 0;
+var _parseHtmlTextContent = require("./parse-html-text-content");
+/**
+ * Creates ADF from HTML string.
+ * This is particularly useful for providing translations in HTML to be supported and we convert back to ADF here
+ * See: https://developer.atlassian.com/platform/localization/i18n-formatting/avoiding-concatenation/
+ *
+ * This function only supports a subset of the schema as it is intended for translations, but it supports
+ * SSR as it has no DOM dependencies and is lightweight.
+ *
+ * @param html - The HTML string to convert to ADF
+ * @returns ADF DocNode or undefined if parsing fails
+ */
+var createADFFromHTML = exports.createADFFromHTML = function createADFFromHTML(html) {
+  return (0, _parseHtmlTextContent.parseHTMLTextContent)(html);
+};

package/dist/cjs/utils/parse-html-text-content.js

@@ -0,0 +1,224 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseHTMLTextContent = exports.getNestingRulesFromSchema = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _schemaDefault = require("@atlaskit/adf-schema/schema-default");
+var _model = require("@atlaskit/editor-prosemirror/model");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var domParser = _model.DOMParser.fromSchema(_schemaDefault.defaultSchema);
+var getNestingRulesFromSchema = exports.getNestingRulesFromSchema = function getNestingRulesFromSchema() {
+  var KEYWORDS = ['inline', 'block', 'text', 'leaf', 'group', 'unsupportedBlock', 'unsupportedInline'];
+  var rules = {};
+  for (var _i = 0, _Object$keys = Object.keys(_schemaDefault.defaultSchema.nodes); _i < _Object$keys.length; _i++) {
+    var _defaultSchema$nodes$;
+    var nodeType = _Object$keys[_i];
+    var contentStr = (_defaultSchema$nodes$ = _schemaDefault.defaultSchema.nodes[nodeType]) === null || _defaultSchema$nodes$ === void 0 ? void 0 : _defaultSchema$nodes$.spec.content;
+    if (!contentStr) {
+      continue;
+    }
+    var allowedChildren =
+    // eslint-disable-next-line require-unicode-regexp
+    (String(contentStr).match(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g) || []).filter(function (match, index, arr) {
+      return !KEYWORDS.includes(match) && _schemaDefault.defaultSchema.nodes[match] && arr.indexOf(match) === index;
+    });
+    if (allowedChildren.length > 0) {
+      rules[nodeType] = allowedChildren;
+    }
+  }
+  return rules;
+};
+var NESTING_RULES = getNestingRulesFromSchema();
+var canContainChildren = function canContainChildren(nodeType) {
+  var _NESTING_RULES$nodeTy;
+  return !!((_NESTING_RULES$nodeTy = NESTING_RULES[nodeType]) !== null && _NESTING_RULES$nodeTy !== void 0 && _NESTING_RULES$nodeTy.length);
+};
+var isAllowedChild = function isAllowedChild(parent, child) {
+  var _NESTING_RULES$parent, _NESTING_RULES$parent2;
+  return (_NESTING_RULES$parent = (_NESTING_RULES$parent2 = NESTING_RULES[parent]) === null || _NESTING_RULES$parent2 === void 0 ? void 0 : _NESTING_RULES$parent2.includes(child)) !== null && _NESTING_RULES$parent !== void 0 ? _NESTING_RULES$parent : false;
+};
+var shouldApplyMark = function shouldApplyMark(tag) {
+  return domParser.rules.some(function (rule) {
+    return 'mark' in rule && rule.tag === tag;
+  });
+};
+var isBlockElement = function isBlockElement(tag) {
+  return domParser.rules.some(function (rule) {
+    return rule.tag === tag && rule.node;
+  });
+};
+var getMarkTypes = function getMarkTypes(tags) {
+  var seen = new Set();
+  var marks = [];
+  var _iterator = _createForOfIteratorHelper(tags),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var _domParser$rules$find;
+      var tag = _step.value;
+      var markType = (_domParser$rules$find = domParser.rules.find(function (rule) {
+        return rule.tag === tag;
+      })) === null || _domParser$rules$find === void 0 ? void 0 : _domParser$rules$find.mark;
+      if (markType && !seen.has(markType)) {
+        marks.push({
+          type: markType
+        });
+        seen.add(markType);
+      }
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return marks;
+};
+var createParagraph = function createParagraph() {
+  var content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return {
+    type: 'paragraph',
+    content: content
+  };
+};
+var getBlockType = function getBlockType(tag) {
+  var rule = domParser.rules.find(function (r) {
+    return r.tag === tag;
+  });
+  return rule && 'node' in rule && rule.node ? rule.node : 'paragraph';
+};
+var createTextNode = function createTextNode(text, marks) {
+  var markTypes = getMarkTypes(marks);
+  return _objectSpread({
+    type: 'text',
+    text: text
+  }, markTypes.length > 0 && {
+    marks: markTypes
+  });
+};
+var addText = function addText(text, marks, content) {
+  if (text) {
+    content.push(createTextNode(text, marks));
+  }
+};
+var handleBlockElement = function handleBlockElement(tag, innerContent, marks, blocks, currentParagraphContent, parseNode, nestedContainer) {
+  // Push any accumulated content as paragraph before block element
+  if (currentParagraphContent.length > 0) {
+    blocks.push(createParagraph((0, _toConsumableArray2.default)(currentParagraphContent)));
+    currentParagraphContent.length = 0;
+  }
+  var blockType = getBlockType(tag);
+  var newMarks = shouldApplyMark(tag) ? [].concat((0, _toConsumableArray2.default)(marks), [tag]) : marks;
+  var parentNodeType = nestedContainer === null || nestedContainer === void 0 ? void 0 : nestedContainer.parentType;
+  if (nestedContainer && parentNodeType && isAllowedChild(parentNodeType, blockType)) {
+    var elementContent = [];
+    var childNestedContainer = canContainChildren(blockType) ? {
+      parentType: blockType,
+      children: elementContent
+    } : nestedContainer;
+    parseNode(innerContent, newMarks, childNestedContainer);
+    if (currentParagraphContent.length > 0) {
+      elementContent.push(createParagraph((0, _toConsumableArray2.default)(currentParagraphContent)));
+      currentParagraphContent.length = 0;
+    }
+    nestedContainer.children.push({
+      type: blockType,
+      content: elementContent.length > 0 ? elementContent : [createParagraph()]
+    });
+  } else if (canContainChildren(blockType)) {
+    var children = [];
+    parseNode(innerContent, newMarks, {
+      parentType: blockType,
+      children: children
+    });
+    blocks.push({
+      type: blockType,
+      content: children.length > 0 ? children : [createParagraph()]
+    });
+  } else {
+    // Regular block elements
+    parseNode(innerContent, newMarks, nestedContainer);
+
+    // Push content generated from block parsing
+    if (currentParagraphContent.length > 0) {
+      if (blockType === 'paragraph' || blockType === 'codeBlock') {
+        blocks.push({
+          type: blockType,
+          content: (0, _toConsumableArray2.default)(currentParagraphContent)
+        });
+      }
+      currentParagraphContent.length = 0;
+    }
+  }
+};
+var handleInlineElement = function handleInlineElement(tag, innerContent, marks, parseNode, nestedContainer) {
+  var newMarks = shouldApplyMark(tag) ? [].concat((0, _toConsumableArray2.default)(marks), [tag]) : marks;
+  parseNode(innerContent, newMarks, nestedContainer);
+};
+
+/**
+ * Simple SSR-compatible parser that recognises text wrapped in HTML elements
+ * and extracts their content as ADF.
+ *
+ * Designed specifically for parsing i18n strings for ADF which specifically need to be
+ * HTML strings for translation.
+ *
+ * Supports nested structures automatically derived from the ADF schema:
+ * - Lists: ul/ol → li (listItem)
+ * - Tables: table → tr (tableRow) → td/th (tableCell/tableHeader)
+ * - Paragraphs, code blocks, and text marks
+ * - Any other nested structures defined in the schema
+ *
+ * @param html - The HTML string to parse
+ * @returns ADF DocNode containing the parsed content
+ */
+var parseHTMLTextContent = exports.parseHTMLTextContent = function parseHTMLTextContent(html) {
+  var blocks = [];
+  var currentParagraphContent = [];
+
+  // Simple regex-based parser that works in both SSR and browser
+  var _parseNode = function parseNode(content) {
+    var marks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var nestedContainer = arguments.length > 2 ? arguments[2] : undefined;
+    // Match HTML tags and text content
+    // eslint-disable-next-line require-unicode-regexp
+    var tagRegex = /<\s*(\w+)([^>]*)>([\s\S]*?)<\s*\/\s*\1\s*>|([^<]+)/g;
+    var match = tagRegex.exec(content);
+    while (match !== null) {
+      if (match[4]) {
+        addText(match[4], marks, currentParagraphContent);
+      } else {
+        // HTML element
+        var tag = match[1].toLowerCase();
+        var innerContent = match[3];
+        if (isBlockElement(tag)) {
+          handleBlockElement(tag, innerContent, marks, blocks, currentParagraphContent, _parseNode, nestedContainer);
+        } else {
+          handleInlineElement(tag, innerContent, marks, _parseNode, nestedContainer);
+        }
+      }
+      match = tagRegex.exec(content);
+    }
+  };
+  _parseNode(html);
+
+  // Push any remaining content
+  if (currentParagraphContent.length > 0) {
+    blocks.push(createParagraph(currentParagraphContent));
+  }
+  return {
+    type: 'doc',
+    version: 1,
+    content: blocks.length > 0 ? blocks : [createParagraph()]
+  };
+};

package/dist/es2019/messages/index.js

@@ -194,5 +194,15 @@ export default defineMessages({
     id: 'fabric.editor.imageEdit',
     defaultMessage: 'Edit image',
     description: 'Crop, flip or rotate the image'
+  },
+  error: {
+    id: 'fabric.editor.error.message.label',
+    defaultMessage: 'Error',
+    description: 'Label for error message icon'
+  },
+  success: {
+    id: 'fabric.editor.success.message.label',
+    defaultMessage: 'Success',
+    description: 'Label for success message icon'
   }
 });

package/dist/es2019/monitoring/error.js

@@ -4,7 +4,7 @@ import { isFedRamp } from './environment';
 import { normaliseSentryBreadcrumbs, SERIALIZABLE_ATTRIBUTES } from './normalise-sentry-breadcrumbs';
 const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-const packageVersion = "110.49.1";
+const packageVersion = "110.49.2";
 const sanitiseSentryEvents = (data, _hint) => {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/es2019/ui/DropList/index.js

@@ -14,7 +14,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags';
 import Layer from '../Layer';
 const packageName = "@atlaskit/editor-common";
-const packageVersion = "110.49.1";
+const packageVersion = "110.49.2";
 const halfFocusRing = 1;
 const dropOffset = '0, 8';
 const fadeIn = keyframes({

package/dist/es2019/ui/Messages/index.js

@@ -5,8 +5,11 @@
 
 // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 import { css, jsx } from '@emotion/react';
+import { useIntl } from 'react-intl-next';
 import ErrorIcon from '@atlaskit/icon/core/status-error';
 import SuccessIcon from '@atlaskit/icon/core/status-success';
+import { fg } from '@atlaskit/platform-feature-flags';
+import commonMessages from '../../messages';
 const errorColor = css({
   color: "var(--ds-text-danger, #AE2E24)"
 });
@@ -40,26 +43,39 @@ export const HelperMessage = ({
 }, children);
 export const ErrorMessage = ({
   children
-}) => jsx("div", {
-  css: () => {
-    return [messageStyle(), errorColor];
-  }
-}, jsx("span", {
-  css: iconWrapperStyle
-}, jsx(ErrorIcon, {
-  LEGACY_size: "small",
-  label: "error",
-  "aria-label": "error"
-})), children);
+}) => {
+  const intl = useIntl();
+  return jsx("div", {
+    css: () => {
+      return [messageStyle(), errorColor];
+    }
+  }, jsx("span", {
+    css: iconWrapperStyle
+  }, fg('platform_editor_dec_a11y_fixes') ? jsx(ErrorIcon, {
+    LEGACY_size: "small",
+    label: intl.formatMessage(commonMessages.error)
+  })
+  /* eslint-disable-next-line @atlassian/i18n/no-literal-string-in-jsx */ : jsx(ErrorIcon, {
+    LEGACY_size: "small",
+    label: "error",
+    "aria-label": "error"
+  })), children);
+};
 export const ValidMessage = ({
   children
-}) => jsx("div", {
-  css: () => {
-    return [messageStyle(), validColor];
-  }
-}, jsx("span", {
-  css: iconWrapperStyle
-}, jsx(SuccessIcon, {
-  LEGACY_size: "small",
-  label: "success"
-})), children);
+}) => {
+  const intl = useIntl();
+  return jsx("div", {
+    css: () => {
+      return [messageStyle(), validColor];
+    }
+  }, jsx("span", {
+    css: iconWrapperStyle
+  }, fg('platform_editor_dec_a11y_fixes') ? jsx(SuccessIcon, {
+    LEGACY_size: "small",
+    label: intl.formatMessage(commonMessages.success)
+  }) : jsx(SuccessIcon, {
+    LEGACY_size: "small",
+    label: "success"
+  })), children);
+};

package/dist/es2019/utils/create-adf-from-html.js

@@ -0,0 +1,16 @@
+import { parseHTMLTextContent } from './parse-html-text-content';
+
+/**
+ * Creates ADF from HTML string.
+ * This is particularly useful for providing translations in HTML to be supported and we convert back to ADF here
+ * See: https://developer.atlassian.com/platform/localization/i18n-formatting/avoiding-concatenation/
+ *
+ * This function only supports a subset of the schema as it is intended for translations, but it supports
+ * SSR as it has no DOM dependencies and is lightweight.
+ *
+ * @param html - The HTML string to convert to ADF
+ * @returns ADF DocNode or undefined if parsing fails
+ */
+export const createADFFromHTML = html => {
+  return parseHTMLTextContent(html);
+};

package/dist/es2019/utils/parse-html-text-content.js

@@ -0,0 +1,179 @@
+import { defaultSchema } from '@atlaskit/adf-schema/schema-default';
+import { DOMParser } from '@atlaskit/editor-prosemirror/model';
+const domParser = DOMParser.fromSchema(defaultSchema);
+export const getNestingRulesFromSchema = () => {
+  const KEYWORDS = ['inline', 'block', 'text', 'leaf', 'group', 'unsupportedBlock', 'unsupportedInline'];
+  const rules = {};
+  for (const nodeType of Object.keys(defaultSchema.nodes)) {
+    var _defaultSchema$nodes$;
+    const contentStr = (_defaultSchema$nodes$ = defaultSchema.nodes[nodeType]) === null || _defaultSchema$nodes$ === void 0 ? void 0 : _defaultSchema$nodes$.spec.content;
+    if (!contentStr) {
+      continue;
+    }
+    const allowedChildren =
+    // eslint-disable-next-line require-unicode-regexp
+    (String(contentStr).match(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g) || []).filter((match, index, arr) => !KEYWORDS.includes(match) && defaultSchema.nodes[match] && arr.indexOf(match) === index);
+    if (allowedChildren.length > 0) {
+      rules[nodeType] = allowedChildren;
+    }
+  }
+  return rules;
+};
+const NESTING_RULES = getNestingRulesFromSchema();
+const canContainChildren = nodeType => {
+  var _NESTING_RULES$nodeTy;
+  return !!((_NESTING_RULES$nodeTy = NESTING_RULES[nodeType]) !== null && _NESTING_RULES$nodeTy !== void 0 && _NESTING_RULES$nodeTy.length);
+};
+const isAllowedChild = (parent, child) => {
+  var _NESTING_RULES$parent, _NESTING_RULES$parent2;
+  return (_NESTING_RULES$parent = (_NESTING_RULES$parent2 = NESTING_RULES[parent]) === null || _NESTING_RULES$parent2 === void 0 ? void 0 : _NESTING_RULES$parent2.includes(child)) !== null && _NESTING_RULES$parent !== void 0 ? _NESTING_RULES$parent : false;
+};
+const shouldApplyMark = tag => domParser.rules.some(rule => 'mark' in rule && rule.tag === tag);
+const isBlockElement = tag => domParser.rules.some(rule => rule.tag === tag && rule.node);
+const getMarkTypes = tags => {
+  const seen = new Set();
+  const marks = [];
+  for (const tag of tags) {
+    var _domParser$rules$find;
+    const markType = (_domParser$rules$find = domParser.rules.find(rule => rule.tag === tag)) === null || _domParser$rules$find === void 0 ? void 0 : _domParser$rules$find.mark;
+    if (markType && !seen.has(markType)) {
+      marks.push({
+        type: markType
+      });
+      seen.add(markType);
+    }
+  }
+  return marks;
+};
+const createParagraph = (content = []) => ({
+  type: 'paragraph',
+  content
+});
+const getBlockType = tag => {
+  const rule = domParser.rules.find(r => r.tag === tag);
+  return rule && 'node' in rule && rule.node ? rule.node : 'paragraph';
+};
+const createTextNode = (text, marks) => {
+  const markTypes = getMarkTypes(marks);
+  return {
+    type: 'text',
+    text,
+    ...(markTypes.length > 0 && {
+      marks: markTypes
+    })
+  };
+};
+const addText = (text, marks, content) => {
+  if (text) {
+    content.push(createTextNode(text, marks));
+  }
+};
+const handleBlockElement = (tag, innerContent, marks, blocks, currentParagraphContent, parseNode, nestedContainer) => {
+  // Push any accumulated content as paragraph before block element
+  if (currentParagraphContent.length > 0) {
+    blocks.push(createParagraph([...currentParagraphContent]));
+    currentParagraphContent.length = 0;
+  }
+  const blockType = getBlockType(tag);
+  const newMarks = shouldApplyMark(tag) ? [...marks, tag] : marks;
+  const parentNodeType = nestedContainer === null || nestedContainer === void 0 ? void 0 : nestedContainer.parentType;
+  if (nestedContainer && parentNodeType && isAllowedChild(parentNodeType, blockType)) {
+    const elementContent = [];
+    const childNestedContainer = canContainChildren(blockType) ? {
+      parentType: blockType,
+      children: elementContent
+    } : nestedContainer;
+    parseNode(innerContent, newMarks, childNestedContainer);
+    if (currentParagraphContent.length > 0) {
+      elementContent.push(createParagraph([...currentParagraphContent]));
+      currentParagraphContent.length = 0;
+    }
+    nestedContainer.children.push({
+      type: blockType,
+      content: elementContent.length > 0 ? elementContent : [createParagraph()]
+    });
+  } else if (canContainChildren(blockType)) {
+    const children = [];
+    parseNode(innerContent, newMarks, {
+      parentType: blockType,
+      children
+    });
+    blocks.push({
+      type: blockType,
+      content: children.length > 0 ? children : [createParagraph()]
+    });
+  } else {
+    // Regular block elements
+    parseNode(innerContent, newMarks, nestedContainer);
+
+    // Push content generated from block parsing
+    if (currentParagraphContent.length > 0) {
+      if (blockType === 'paragraph' || blockType === 'codeBlock') {
+        blocks.push({
+          type: blockType,
+          content: [...currentParagraphContent]
+        });
+      }
+      currentParagraphContent.length = 0;
+    }
+  }
+};
+const handleInlineElement = (tag, innerContent, marks, parseNode, nestedContainer) => {
+  const newMarks = shouldApplyMark(tag) ? [...marks, tag] : marks;
+  parseNode(innerContent, newMarks, nestedContainer);
+};
+
+/**
+ * Simple SSR-compatible parser that recognises text wrapped in HTML elements
+ * and extracts their content as ADF.
+ *
+ * Designed specifically for parsing i18n strings for ADF which specifically need to be
+ * HTML strings for translation.
+ *
+ * Supports nested structures automatically derived from the ADF schema:
+ * - Lists: ul/ol → li (listItem)
+ * - Tables: table → tr (tableRow) → td/th (tableCell/tableHeader)
+ * - Paragraphs, code blocks, and text marks
+ * - Any other nested structures defined in the schema
+ *
+ * @param html - The HTML string to parse
+ * @returns ADF DocNode containing the parsed content
+ */
+export const parseHTMLTextContent = html => {
+  const blocks = [];
+  const currentParagraphContent = [];
+
+  // Simple regex-based parser that works in both SSR and browser
+  const parseNode = (content, marks = [], nestedContainer) => {
+    // Match HTML tags and text content
+    // eslint-disable-next-line require-unicode-regexp
+    const tagRegex = /<\s*(\w+)([^>]*)>([\s\S]*?)<\s*\/\s*\1\s*>|([^<]+)/g;
+    let match = tagRegex.exec(content);
+    while (match !== null) {
+      if (match[4]) {
+        addText(match[4], marks, currentParagraphContent);
+      } else {
+        // HTML element
+        const tag = match[1].toLowerCase();
+        const innerContent = match[3];
+        if (isBlockElement(tag)) {
+          handleBlockElement(tag, innerContent, marks, blocks, currentParagraphContent, parseNode, nestedContainer);
+        } else {
+          handleInlineElement(tag, innerContent, marks, parseNode, nestedContainer);
+        }
+      }
+      match = tagRegex.exec(content);
+    }
+  };
+  parseNode(html);
+
+  // Push any remaining content
+  if (currentParagraphContent.length > 0) {
+    blocks.push(createParagraph(currentParagraphContent));
+  }
+  return {
+    type: 'doc',
+    version: 1,
+    content: blocks.length > 0 ? blocks : [createParagraph()]
+  };
+};

package/dist/esm/messages/index.js

@@ -194,5 +194,15 @@ export default defineMessages({
     id: 'fabric.editor.imageEdit',
     defaultMessage: 'Edit image',
     description: 'Crop, flip or rotate the image'
+  },
+  error: {
+    id: 'fabric.editor.error.message.label',
+    defaultMessage: 'Error',
+    description: 'Label for error message icon'
+  },
+  success: {
+    id: 'fabric.editor.success.message.label',
+    defaultMessage: 'Success',
+    description: 'Label for success message icon'
   }
 });

package/dist/esm/monitoring/error.js

@@ -10,7 +10,7 @@ import { isFedRamp } from './environment';
 import { normaliseSentryBreadcrumbs, SERIALIZABLE_ATTRIBUTES } from './normalise-sentry-breadcrumbs';
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "110.49.1";
+var packageVersion = "110.49.2";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/esm/ui/DropList/index.js

@@ -21,7 +21,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "110.49.1";
+var packageVersion = "110.49.2";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = keyframes({

package/dist/esm/ui/Messages/index.js

@@ -5,8 +5,11 @@
 
 // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 import { css, jsx } from '@emotion/react';
+import { useIntl } from 'react-intl-next';
 import ErrorIcon from '@atlaskit/icon/core/status-error';
 import SuccessIcon from '@atlaskit/icon/core/status-success';
+import { fg } from '@atlaskit/platform-feature-flags';
+import commonMessages from '../../messages';
 var errorColor = css({
   color: "var(--ds-text-danger, #AE2E24)"
 });
@@ -44,13 +47,18 @@ export var HelperMessage = function HelperMessage(_ref) {
 };
 export var ErrorMessage = function ErrorMessage(_ref2) {
   var children = _ref2.children;
+  var intl = useIntl();
   return jsx("div", {
     css: function css() {
       return [messageStyle(), errorColor];
     }
   }, jsx("span", {
     css: iconWrapperStyle
-  }, jsx(ErrorIcon, {
+  }, fg('platform_editor_dec_a11y_fixes') ? jsx(ErrorIcon, {
+    LEGACY_size: "small",
+    label: intl.formatMessage(commonMessages.error)
+  })
+  /* eslint-disable-next-line @atlassian/i18n/no-literal-string-in-jsx */ : jsx(ErrorIcon, {
     LEGACY_size: "small",
     label: "error",
     "aria-label": "error"
@@ -58,13 +66,17 @@ export var ErrorMessage = function ErrorMessage(_ref2) {
 };
 export var ValidMessage = function ValidMessage(_ref3) {
   var children = _ref3.children;
+  var intl = useIntl();
   return jsx("div", {
     css: function css() {
       return [messageStyle(), validColor];
     }
   }, jsx("span", {
     css: iconWrapperStyle
-  }, jsx(SuccessIcon, {
+  }, fg('platform_editor_dec_a11y_fixes') ? jsx(SuccessIcon, {
+    LEGACY_size: "small",
+    label: intl.formatMessage(commonMessages.success)
+  }) : jsx(SuccessIcon, {
     LEGACY_size: "small",
     label: "success"
   })), children);

package/dist/esm/utils/create-adf-from-html.js

@@ -0,0 +1,16 @@
+import { parseHTMLTextContent } from './parse-html-text-content';
+
+/**
+ * Creates ADF from HTML string.
+ * This is particularly useful for providing translations in HTML to be supported and we convert back to ADF here
+ * See: https://developer.atlassian.com/platform/localization/i18n-formatting/avoiding-concatenation/
+ *
+ * This function only supports a subset of the schema as it is intended for translations, but it supports
+ * SSR as it has no DOM dependencies and is lightweight.
+ *
+ * @param html - The HTML string to convert to ADF
+ * @returns ADF DocNode or undefined if parsing fails
+ */
+export var createADFFromHTML = function createADFFromHTML(html) {
+  return parseHTMLTextContent(html);
+};

package/dist/esm/utils/parse-html-text-content.js

@@ -0,0 +1,217 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { defaultSchema } from '@atlaskit/adf-schema/schema-default';
+import { DOMParser } from '@atlaskit/editor-prosemirror/model';
+var domParser = DOMParser.fromSchema(defaultSchema);
+export var getNestingRulesFromSchema = function getNestingRulesFromSchema() {
+  var KEYWORDS = ['inline', 'block', 'text', 'leaf', 'group', 'unsupportedBlock', 'unsupportedInline'];
+  var rules = {};
+  for (var _i = 0, _Object$keys = Object.keys(defaultSchema.nodes); _i < _Object$keys.length; _i++) {
+    var _defaultSchema$nodes$;
+    var nodeType = _Object$keys[_i];
+    var contentStr = (_defaultSchema$nodes$ = defaultSchema.nodes[nodeType]) === null || _defaultSchema$nodes$ === void 0 ? void 0 : _defaultSchema$nodes$.spec.content;
+    if (!contentStr) {
+      continue;
+    }
+    var allowedChildren =
+    // eslint-disable-next-line require-unicode-regexp
+    (String(contentStr).match(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g) || []).filter(function (match, index, arr) {
+      return !KEYWORDS.includes(match) && defaultSchema.nodes[match] && arr.indexOf(match) === index;
+    });
+    if (allowedChildren.length > 0) {
+      rules[nodeType] = allowedChildren;
+    }
+  }
+  return rules;
+};
+var NESTING_RULES = getNestingRulesFromSchema();
+var canContainChildren = function canContainChildren(nodeType) {
+  var _NESTING_RULES$nodeTy;
+  return !!((_NESTING_RULES$nodeTy = NESTING_RULES[nodeType]) !== null && _NESTING_RULES$nodeTy !== void 0 && _NESTING_RULES$nodeTy.length);
+};
+var isAllowedChild = function isAllowedChild(parent, child) {
+  var _NESTING_RULES$parent, _NESTING_RULES$parent2;
+  return (_NESTING_RULES$parent = (_NESTING_RULES$parent2 = NESTING_RULES[parent]) === null || _NESTING_RULES$parent2 === void 0 ? void 0 : _NESTING_RULES$parent2.includes(child)) !== null && _NESTING_RULES$parent !== void 0 ? _NESTING_RULES$parent : false;
+};
+var shouldApplyMark = function shouldApplyMark(tag) {
+  return domParser.rules.some(function (rule) {
+    return 'mark' in rule && rule.tag === tag;
+  });
+};
+var isBlockElement = function isBlockElement(tag) {
+  return domParser.rules.some(function (rule) {
+    return rule.tag === tag && rule.node;
+  });
+};
+var getMarkTypes = function getMarkTypes(tags) {
+  var seen = new Set();
+  var marks = [];
+  var _iterator = _createForOfIteratorHelper(tags),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var _domParser$rules$find;
+      var tag = _step.value;
+      var markType = (_domParser$rules$find = domParser.rules.find(function (rule) {
+        return rule.tag === tag;
+      })) === null || _domParser$rules$find === void 0 ? void 0 : _domParser$rules$find.mark;
+      if (markType && !seen.has(markType)) {
+        marks.push({
+          type: markType
+        });
+        seen.add(markType);
+      }
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return marks;
+};
+var createParagraph = function createParagraph() {
+  var content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return {
+    type: 'paragraph',
+    content: content
+  };
+};
+var getBlockType = function getBlockType(tag) {
+  var rule = domParser.rules.find(function (r) {
+    return r.tag === tag;
+  });
+  return rule && 'node' in rule && rule.node ? rule.node : 'paragraph';
+};
+var createTextNode = function createTextNode(text, marks) {
+  var markTypes = getMarkTypes(marks);
+  return _objectSpread({
+    type: 'text',
+    text: text
+  }, markTypes.length > 0 && {
+    marks: markTypes
+  });
+};
+var addText = function addText(text, marks, content) {
+  if (text) {
+    content.push(createTextNode(text, marks));
+  }
+};
+var handleBlockElement = function handleBlockElement(tag, innerContent, marks, blocks, currentParagraphContent, parseNode, nestedContainer) {
+  // Push any accumulated content as paragraph before block element
+  if (currentParagraphContent.length > 0) {
+    blocks.push(createParagraph(_toConsumableArray(currentParagraphContent)));
+    currentParagraphContent.length = 0;
+  }
+  var blockType = getBlockType(tag);
+  var newMarks = shouldApplyMark(tag) ? [].concat(_toConsumableArray(marks), [tag]) : marks;
+  var parentNodeType = nestedContainer === null || nestedContainer === void 0 ? void 0 : nestedContainer.parentType;
+  if (nestedContainer && parentNodeType && isAllowedChild(parentNodeType, blockType)) {
+    var elementContent = [];
+    var childNestedContainer = canContainChildren(blockType) ? {
+      parentType: blockType,
+      children: elementContent
+    } : nestedContainer;
+    parseNode(innerContent, newMarks, childNestedContainer);
+    if (currentParagraphContent.length > 0) {
+      elementContent.push(createParagraph(_toConsumableArray(currentParagraphContent)));
+      currentParagraphContent.length = 0;
+    }
+    nestedContainer.children.push({
+      type: blockType,
+      content: elementContent.length > 0 ? elementContent : [createParagraph()]
+    });
+  } else if (canContainChildren(blockType)) {
+    var children = [];
+    parseNode(innerContent, newMarks, {
+      parentType: blockType,
+      children: children
+    });
+    blocks.push({
+      type: blockType,
+      content: children.length > 0 ? children : [createParagraph()]
+    });
+  } else {
+    // Regular block elements
+    parseNode(innerContent, newMarks, nestedContainer);
+
+    // Push content generated from block parsing
+    if (currentParagraphContent.length > 0) {
+      if (blockType === 'paragraph' || blockType === 'codeBlock') {
+        blocks.push({
+          type: blockType,
+          content: _toConsumableArray(currentParagraphContent)
+        });
+      }
+      currentParagraphContent.length = 0;
+    }
+  }
+};
+var handleInlineElement = function handleInlineElement(tag, innerContent, marks, parseNode, nestedContainer) {
+  var newMarks = shouldApplyMark(tag) ? [].concat(_toConsumableArray(marks), [tag]) : marks;
+  parseNode(innerContent, newMarks, nestedContainer);
+};
+
+/**
+ * Simple SSR-compatible parser that recognises text wrapped in HTML elements
+ * and extracts their content as ADF.
+ *
+ * Designed specifically for parsing i18n strings for ADF which specifically need to be
+ * HTML strings for translation.
+ *
+ * Supports nested structures automatically derived from the ADF schema:
+ * - Lists: ul/ol → li (listItem)
+ * - Tables: table → tr (tableRow) → td/th (tableCell/tableHeader)
+ * - Paragraphs, code blocks, and text marks
+ * - Any other nested structures defined in the schema
+ *
+ * @param html - The HTML string to parse
+ * @returns ADF DocNode containing the parsed content
+ */
+export var parseHTMLTextContent = function parseHTMLTextContent(html) {
+  var blocks = [];
+  var currentParagraphContent = [];
+
+  // Simple regex-based parser that works in both SSR and browser
+  var _parseNode = function parseNode(content) {
+    var marks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var nestedContainer = arguments.length > 2 ? arguments[2] : undefined;
+    // Match HTML tags and text content
+    // eslint-disable-next-line require-unicode-regexp
+    var tagRegex = /<\s*(\w+)([^>]*)>([\s\S]*?)<\s*\/\s*\1\s*>|([^<]+)/g;
+    var match = tagRegex.exec(content);
+    while (match !== null) {
+      if (match[4]) {
+        addText(match[4], marks, currentParagraphContent);
+      } else {
+        // HTML element
+        var tag = match[1].toLowerCase();
+        var innerContent = match[3];
+        if (isBlockElement(tag)) {
+          handleBlockElement(tag, innerContent, marks, blocks, currentParagraphContent, _parseNode, nestedContainer);
+        } else {
+          handleInlineElement(tag, innerContent, marks, _parseNode, nestedContainer);
+        }
+      }
+      match = tagRegex.exec(content);
+    }
+  };
+  _parseNode(html);
+
+  // Push any remaining content
+  if (currentParagraphContent.length > 0) {
+    blocks.push(createParagraph(currentParagraphContent));
+  }
+  return {
+    type: 'doc',
+    version: 1,
+    content: blocks.length > 0 ? blocks : [createParagraph()]
+  };
+};

package/dist/types/messages/index.d.ts

@@ -191,5 +191,15 @@ declare const _default: {
         defaultMessage: string;
         description: string;
     };
+    error: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    success: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
 };
 export default _default;

package/dist/types/utils/create-adf-from-html.d.ts

@@ -0,0 +1,13 @@
+import type { DocNode } from '@atlaskit/adf-schema';
+/**
+ * Creates ADF from HTML string.
+ * This is particularly useful for providing translations in HTML to be supported and we convert back to ADF here
+ * See: https://developer.atlassian.com/platform/localization/i18n-formatting/avoiding-concatenation/
+ *
+ * This function only supports a subset of the schema as it is intended for translations, but it supports
+ * SSR as it has no DOM dependencies and is lightweight.
+ *
+ * @param html - The HTML string to convert to ADF
+ * @returns ADF DocNode or undefined if parsing fails
+ */
+export declare const createADFFromHTML: (html: string) => DocNode;

package/dist/types/utils/parse-html-text-content.d.ts

@@ -0,0 +1,19 @@
+import type { DocNode } from '@atlaskit/adf-schema';
+export declare const getNestingRulesFromSchema: () => Record<string, string[]>;
+/**
+ * Simple SSR-compatible parser that recognises text wrapped in HTML elements
+ * and extracts their content as ADF.
+ *
+ * Designed specifically for parsing i18n strings for ADF which specifically need to be
+ * HTML strings for translation.
+ *
+ * Supports nested structures automatically derived from the ADF schema:
+ * - Lists: ul/ol → li (listItem)
+ * - Tables: table → tr (tableRow) → td/th (tableCell/tableHeader)
+ * - Paragraphs, code blocks, and text marks
+ * - Any other nested structures defined in the schema
+ *
+ * @param html - The HTML string to parse
+ * @returns ADF DocNode containing the parsed content
+ */
+export declare const parseHTMLTextContent: (html: string) => DocNode;

package/dist/types-ts4.5/messages/index.d.ts

@@ -191,5 +191,15 @@ declare const _default: {
         defaultMessage: string;
         description: string;
     };
+    error: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    success: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
 };
 export default _default;

package/dist/types-ts4.5/utils/create-adf-from-html.d.ts

@@ -0,0 +1,13 @@
+import type { DocNode } from '@atlaskit/adf-schema';
+/**
+ * Creates ADF from HTML string.
+ * This is particularly useful for providing translations in HTML to be supported and we convert back to ADF here
+ * See: https://developer.atlassian.com/platform/localization/i18n-formatting/avoiding-concatenation/
+ *
+ * This function only supports a subset of the schema as it is intended for translations, but it supports
+ * SSR as it has no DOM dependencies and is lightweight.
+ *
+ * @param html - The HTML string to convert to ADF
+ * @returns ADF DocNode or undefined if parsing fails
+ */
+export declare const createADFFromHTML: (html: string) => DocNode;

package/dist/types-ts4.5/utils/parse-html-text-content.d.ts

@@ -0,0 +1,19 @@
+import type { DocNode } from '@atlaskit/adf-schema';
+export declare const getNestingRulesFromSchema: () => Record<string, string[]>;
+/**
+ * Simple SSR-compatible parser that recognises text wrapped in HTML elements
+ * and extracts their content as ADF.
+ *
+ * Designed specifically for parsing i18n strings for ADF which specifically need to be
+ * HTML strings for translation.
+ *
+ * Supports nested structures automatically derived from the ADF schema:
+ * - Lists: ul/ol → li (listItem)
+ * - Tables: table → tr (tableRow) → td/th (tableCell/tableHeader)
+ * - Paragraphs, code blocks, and text marks
+ * - Any other nested structures defined in the schema
+ *
+ * @param html - The HTML string to parse
+ * @returns ADF DocNode containing the parsed content
+ */
+export declare const parseHTMLTextContent: (html: string) => DocNode;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "110.49.2",
+	"version": "110.50.0",
 	"description": "A package that contains common classes and components for editor and renderer",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -81,7 +81,7 @@
 		"@atlaskit/task-decision": "^19.2.0",
 		"@atlaskit/textfield": "^8.2.0",
 		"@atlaskit/theme": "^21.0.0",
-		"@atlaskit/tmp-editor-statsig": "^16.2.0",
+		"@atlaskit/tmp-editor-statsig": "^16.3.0",
 		"@atlaskit/tokens": "^9.0.0",
 		"@atlaskit/tooltip": "^20.11.0",
 		"@atlaskit/width-detector": "^5.0.0",

package/utils/create-adf-from-html/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@atlaskit/editor-common/utils/create-adf-from-html",
+  "main": "../../dist/cjs/utils/create-adf-from-html.js",
+  "module": "../../dist/esm/utils/create-adf-from-html.js",
+  "module:es2019": "../../dist/es2019/utils/create-adf-from-html.js",
+  "sideEffects": [
+    "**/*.compiled.css"
+  ],
+  "types": "../../dist/types/utils/create-adf-from-html.d.ts",
+  "typesVersions": {
+    ">=4.5 <5.9": {
+      "*": [
+        "../../dist/types-ts4.5/utils/create-adf-from-html.d.ts"
+      ]
+    }
+  }
+}