@atlaskit/editor-common 115.5.0 → 115.6.0

package/dist/es2019/utils/hyperlink.js

@@ -1,18 +1,67 @@
 // File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/utils/hyperlink.ts
 // If changes are made to this file, please make the same update in the linked file.
 
-import { linkify } from '@atlaskit/adf-schema';
+import { isSafeUrl, linkify, normalizeUrl as normaliseLinkHref } from '@atlaskit/adf-schema';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../analytics/types/enums';
-import { FILEPATH_REGEXP } from './FILEPATH_REGEXP';
-import { getLinkDomain } from './getLinkDomain';
-import { normalizeUrl } from './normalizeUrl';
 import { shouldAutoLinkifyMatch } from './should-auto-linkify-tld';
 import { mapSlice } from './slice';
 
+/* eslint-disable require-unicode-regexp -- Omit `u` so emitDeclarationOnly build (pre-ES2015 lib) does not error TS1501; patterns are ASCII-only paths and $/{ prefix. */
+// Regular expression for a windows filepath in the format <DRIVE LETTER>:\<folder name>\
+// Ignored via go/ees005
+export const FILEPATH_REGEXP = /([a-zA-Z]:|\\)([^\/:*?<>"|]+\\)?([^\/:*?<>"| ]+(?=\s?))?/gim;
+
 // Don't linkify if starts with $ or {
 // Ignored via go/ees005
-// eslint-disable-next-line require-unicode-regexp
 export const DONTLINKIFY_REGEXP = /^(\$|\{)/;
+/* eslint-enable require-unicode-regexp */
+
+/**
+ * Instance of class LinkMatcher are used in autoformatting in place of Regex.
+ * Hence it has been made similar to regex with an exec method.
+ * Extending it directly from class Regex was introducing some issues, thus that has been avoided.
+ */
+export class LinkMatcher {
+  static create() {
+    class LinkMatcherRegex {
+      exec(str) {
+        const stringsBySpace = str.slice(0, str.length - 1).split(' ');
+        const lastStringBeforeSpace = stringsBySpace[stringsBySpace.length - 1];
+        const isLastStringValid = lastStringBeforeSpace.length > 0;
+        if (!str.endsWith(' ') || !isLastStringValid) {
+          return null;
+        }
+        if (DONTLINKIFY_REGEXP.test(lastStringBeforeSpace)) {
+          return null;
+        }
+        const links = linkify.match(lastStringBeforeSpace);
+        if (!links || links.length === 0) {
+          return null;
+        }
+        const lastMatch = links[links.length - 1];
+        const lastLink = links[links.length - 1];
+        lastLink.input = str.substring(lastMatch.index);
+        lastLink.length = lastLink.lastIndex - lastLink.index + 1;
+        lastLink.index = str.lastIndexOf(lastStringBeforeSpace) + lastMatch.index;
+        return lastLink;
+      }
+    }
+    return new LinkMatcherRegex();
+  }
+}
+
+/**
+ * Adds protocol to url if needed.
+ */
+export function normalizeUrl(url) {
+  if (!url) {
+    return '';
+  }
+  if (isSafeUrl(url)) {
+    return url;
+  }
+  return normaliseLinkHref(url);
+}
 
 /**
  * Linkify content in a slice (eg. after a rich text paste)
@@ -53,6 +102,22 @@ export function linkifyContent(schema) {
   });
 }
 
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function getLinkDomain(url) {
+  // Remove protocol and www., if either exists
+  // Ignored via go/ees005
+  // eslint-disable-next-line require-unicode-regexp
+  const withoutProtocol = url.toLowerCase().replace(/^(.*):\/\//, '');
+  // Ignored via go/ees005
+  // eslint-disable-next-line require-unicode-regexp
+  const withoutWWW = withoutProtocol.replace(/^(www\.)/, '');
+
+  // Remove port, fragment, path, query string
+  // Ignored via go/ees005
+  // eslint-disable-next-line require-unicode-regexp
+  return withoutWWW.replace(/[:\/?#](.*)$/, '');
+}
+
 // eslint-disable-next-line jsdoc/require-jsdoc
 export function isFromCurrentDomain(url) {
   if (!window || !window.location) {
@@ -122,13 +187,22 @@ export function getLinkCreationAnalyticsEvent(inputMethod, url) {
     }
   };
 }
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { FILEPATH_REGEXP } from './FILEPATH_REGEXP';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { LinkMatcher } from './LinkMatcher';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { normalizeUrl } from './normalizeUrl';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { getLinkDomain } from './getLinkDomain';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { canLinkBeCreatedInRange } from './canLinkBeCreatedInRange';
+export const canLinkBeCreatedInRange = (from, to) => state => {
+  if (!state.doc.rangeHasMark(from, to, state.schema.marks.link)) {
+    const $from = state.doc.resolve(from);
+    const $to = state.doc.resolve(to);
+    const link = state.schema.marks.link;
+    if ($from.parent === $to.parent && $from.parent.isTextblock) {
+      if ($from.parent.type.allowsMarkType(link)) {
+        let allowed = true;
+        state.doc.nodesBetween(from, to, node => {
+          const hasInlineCard = node.type === state.schema.nodes.inlineCard;
+          allowed = allowed && !node.marks.some(m => m.type.excludes(link)) && !hasInlineCard;
+          return allowed;
+        });
+        return allowed;
+      }
+    }
+  }
+  return false;
+};

package/dist/es2019/utils/index.js

@@ -2,8 +2,8 @@
 /* eslint-disable @atlaskit/editor/no-re-export */
 
 import { hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
-import { hasDocAsParent } from './hasDocAsParent';
-import { isEmptyParagraph } from './isEmptyParagraph';
+import { hasDocAsParent } from './document';
+import { isEmptyParagraph } from './editor-core-utils';
 export { shouldAutoLinkifyMatch } from './should-auto-linkify-tld';
 export { getAnnotationMarksForPos, canApplyAnnotationOnRange, containsAnyAnnotations, getAnnotationIdsFromRange, getAnnotationInlineNodeTypes, hasAnnotationMark, getRangeInlineNodeNames, getRangeAncestorNodeNames, isEmptyTextSelection, isEmptyTextSelectionRenderer } from './annotation';
 export { getExtensionLozengeData } from './macro';
@@ -16,43 +16,37 @@ export {
  */
 ErrorReporter } from './error-reporter';
 export { isPastDate, timestampToIsoFormat, timestampToString, timestampToTaskContext, timestampToUTCDate, todayTimestampInUTC } from './date';
-export { stepAddsOneOf, removeBlockMarks } from './editor-core-utils';
-export { extractSliceFromStep } from './extractSliceFromStep';
-export { filterChildrenBetween } from './filterChildrenBetween';
-export { isElementInTableCell } from './isElementInTableCell';
-export { isEmptyParagraph } from './isEmptyParagraph';
-export { isInLayoutColumn } from './isInLayoutColumn';
-export { isLastItemMediaGroup } from './isLastItemMediaGroup';
-export { isTextSelection } from './isTextSelection';
-export { isValidPosition } from './isValidPosition';
-export { nonNullable } from './nonNullable';
-export { setAllSelection } from './setAllSelection';
-export { setCellSelection } from './setCellSelection';
-export { setNodeSelection } from './setNodeSelection';
-export { setTextSelection } from './setTextSelection';
-export { stepHasSlice } from './stepHasSlice';
+export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, setAllSelection, setCellSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition, isEmptyParagraph, isInLayoutColumn, removeBlockMarks, filterChildrenBetween } from './editor-core-utils';
 export { withImageLoader } from './imageLoader';
-export { absoluteBreakoutWidth, calcBreakoutWidth, calcWideWidth, breakoutConsts, calculateBreakoutStyles, calcBreakoutWidthPx, calcBreakoutWithCustomWidth } from './breakout';
-export { breakoutResizableNodes } from './breakoutResizableNodes';
-export { getBreakoutResizableNodeTypes } from './getBreakoutResizableNodeTypes';
-export { getNextBreakoutMode } from './getNextBreakoutMode';
-export { getTitle } from './getTitle';
-export { SelectedState } from './SelectedState';
-export { findChangedNodesFromTransaction } from './findChangedNodesFromTransaction';
-export { isMediaNode } from './isMediaNode';
-export { isNodeBeforeMediaNode } from './isNodeBeforeMediaNode';
-export { isSupportedInParent } from './isSupportedInParent';
-export { validateNodes, isType, isParagraph, isText, isLinkMark, isNodeSelectedOrInRange } from './nodes';
-export { validNode } from './validNode';
+export { breakoutResizableNodes, getBreakoutResizableNodeTypes, absoluteBreakoutWidth, calcBreakoutWidth, calcWideWidth, breakoutConsts, calculateBreakoutStyles, calcBreakoutWidthPx, getNextBreakoutMode, getTitle, calcBreakoutWithCustomWidth } from './breakout';
+export {
+/**
+ * @private
+ * @deprecated
+ *
+ * This is only used in editor-core and shouldn't be used anywhere else.
+ * If you do need it please reach out to #cc-editor-lego
+ */
+findChangedNodesFromTransaction,
+/**
+ * @private
+ * @deprecated
+ *
+ * This is only used in editor-core and shouldn't be used anywhere else.
+ * If you do need it please reach out to #cc-editor-lego
+ */
+validNode,
+/**
+ * @private
+ * @deprecated
+ *
+ * This is only used in editor-core and shouldn't be used anywhere else.
+ * If you do need it please reach out to #cc-editor-lego
+ */
+validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent, isMediaNode, isNodeBeforeMediaNode } from './nodes';
 export { pluginFactory } from './plugin-state-factory';
-export { getFragmentBackingArray } from './getFragmentBackingArray';
-export { mapFragment, mapSlice, flatmap, mapChildren, hasNode } from './slice';
-export { containsClassName } from './containsClassName';
-export { closest, closestElement, mapElem, maphElem } from './dom';
-export { parsePx } from './parsePx';
-export { removeNestedEmptyEls } from './removeNestedEmptyEls';
-export { unwrap } from './unwrap';
-export { walkUpTreeUntil } from './walkUpTreeUntil';
+export { getFragmentBackingArray, mapFragment, mapSlice, flatmap, mapChildren, hasNode } from './slice';
+export { walkUpTreeUntil, unwrap, removeNestedEmptyEls, containsClassName, closest, closestElement, parsePx, mapElem, maphElem } from './dom';
 export { default as ADFTraversor } from './traversor';
 /**
  * @private
@@ -60,12 +54,8 @@ export { default as ADFTraversor } from './traversor';
  *
  * Use entry-point `@atlaskit/editor-common/utils/analytics` instead
  */
-export { SEVERITY } from './SEVERITY';
-export { analyticsEventKey, getAnalyticsEditorAppearance, getAnalyticsEventSeverity } from './analytics';
-export { getAnalyticsAppearance } from './getAnalyticsAppearance';
-export { UNSUPPORTED_CONTENT_LEVEL_SEVERITY } from './unsupportedContent/UNSUPPORTED_CONTENT_LEVEL_SEVERITY';
-export { UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS } from './unsupportedContent/UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS';
-export { getUnsupportedContentLevelData } from './unsupportedContent/get-unsupported-content-level-data';
+export { analyticsEventKey, getAnalyticsAppearance, getAnalyticsEditorAppearance, getAnalyticsEventSeverity, SEVERITY } from './analytics';
+export { getUnsupportedContentLevelData, UNSUPPORTED_CONTENT_LEVEL_SEVERITY, UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS } from './unsupportedContent/get-unsupported-content-level-data';
 export { findAndTrackUnsupportedContentNodes } from './track-unsupported-content';
 export {
 /**
@@ -83,9 +73,31 @@ getDistortedDurationMonitor,
  */
 measureRender } from './performance/measure-render';
 export { startMeasure, stopMeasure, clearMeasure } from './performance/measure';
-export { TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS } from './performance/TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS';
-export { TTI_SEVERITY_THRESHOLD_DEFAULTS } from './performance/TTI_SEVERITY_THRESHOLD_DEFAULTS';
-export { measureTTI, getTTISeverity } from './performance/measure-tti';
+export {
+/**
+ * @private
+ * @deprecated
+ * Private API - should not be used. Use `@atlaskit/editor-common/performance/measure-tti` if required.
+ */
+measureTTI,
+/**
+ * @private
+ * @deprecated
+ * Private API - should not be used. Use `@atlaskit/editor-common/performance/measure-tti` if required.
+ */
+getTTISeverity,
+/**
+ * @private
+ * @deprecated
+ * Private API - should not be used. Use `@atlaskit/editor-common/performance/measure-tti` if required.
+ */
+TTI_SEVERITY_THRESHOLD_DEFAULTS,
+/**
+ * @private
+ * @deprecated
+ * Private API - should not be used. Use `@atlaskit/editor-common/performance/measure-tti` if required.
+ */
+TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS } from './performance/measure-tti';
 /**
  * @private
  * @deprecated
@@ -93,21 +105,16 @@ export { measureTTI, getTTISeverity } from './performance/measure-tti';
  * Private API - should not be used. Use `@atlaskit/editor-common/is-performance-api-available` if required.
  *
  */
-export { isPerformanceAPIAvailable } from './performance/is-performance-api-available';
-export { isPerformanceObserverAvailable } from './performance/isPerformanceObserverAvailable';
+export { isPerformanceAPIAvailable, isPerformanceObserverAvailable } from './performance/is-performance-api-available';
 /**
  * @private
  * @deprecated
  *
  * Private API - should not be used. Use `@atlaskit/editor-common/performance/navigation` if required.
  */
-export { getRequestToResponseTime } from './performance/getRequestToResponseTime';
-export { getResponseEndTime } from './performance/getResponseEndTime';
+export { getRequestToResponseTime, getResponseEndTime } from './performance/navigation';
 export { getExtensionRenderer } from './extension-handler';
-export { convertProsemirrorTableNodeToArrayOfRows } from './convertProsemirrorTableNodeToArrayOfRows';
-export { hasMergedCell } from './hasMergedCell';
-export { isPositionNearTableRow } from './isPositionNearTableRow';
-export { getColumnWidths, calcTableColumnWidths } from './table';
+export { hasMergedCell, getColumnWidths, calcTableColumnWidths, convertProsemirrorTableNodeToArrayOfRows, isPositionNearTableRow } from './table';
 export { createCompareNodes } from './compareNodes';
 export { compose } from './compose';
 export { isTextInput } from './is-text-input';
@@ -118,8 +125,7 @@ export { isTextInput } from './is-text-input';
 export { ZERO_WIDTH_SPACE, ZERO_WIDTH_JOINER } from '../whitespace';
 export { shouldForceTracking } from './should-force-tracking';
 export { getModeFromTheme } from './getModeFromTheme';
-export { getPerformanceOptions, stopMeasureReactNodeViewRendered } from './get-performance-options';
-export { startMeasureReactNodeViewRendered } from './startMeasureReactNodeViewRendered';
+export { getPerformanceOptions, startMeasureReactNodeViewRendered, stopMeasureReactNodeViewRendered } from './get-performance-options';
 export { sniffUserBrowserExtensions } from './browser-extensions';
 export { RenderCountProfiler, PROFILER_KEY } from './profiler/render-count';
 export { validateADFEntity, validationErrorHandler } from './validate-using-spec';
@@ -139,20 +145,9 @@ useComponentRenderTracking } from './performance/hooks/use-component-render-trac
  * Private API do not use
  */
 export { autoJoinTr } from './prosemirror/autojoin';
-export { getNodeName } from './getNodeName';
-export { isReferencedSource, removeConnectedNodes, getChildrenInfo } from './referentiality';
-export { isBulletList } from './isBulletList';
-export { isListItemNode } from './isListItemNode';
-export { isListNode } from './isListNode';
-export { isParagraphNode } from './isParagraphNode';
-export { getItemCounterDigitsSize, getOrderFromOrderedListNode } from './list';
-export { resolveOrder } from './resolveOrder';
-export { FILEPATH_REGEXP } from './FILEPATH_REGEXP';
-export { LinkMatcher } from './LinkMatcher';
-export { canLinkBeCreatedInRange } from './canLinkBeCreatedInRange';
-export { getLinkDomain } from './getLinkDomain';
-export { isFromCurrentDomain, linkifyContent, findFilepaths, isLinkInMatches, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent } from './hyperlink';
-export { normalizeUrl } from './normalizeUrl';
+export { isReferencedSource, removeConnectedNodes, getChildrenInfo, getNodeName } from './referentiality';
+export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder, isListNode, isParagraphNode, isListItemNode, isBulletList } from './list';
+export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLinkDomain, findFilepaths, isLinkInMatches, FILEPATH_REGEXP, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent, canLinkBeCreatedInRange } from './hyperlink';
 
 // prosemirror-history does not export its plugin key
 export const pmHistoryPluginKey = 'history$';
@@ -164,12 +159,7 @@ export { gridTypeForLayout } from './grid';
  *
  * Use `@atlaskit/editor-common/utils/document` entry-point instead.
  */
-export { nodesBetweenChanged, bracketTyped, getChangedNodes } from './document';
-export { getStepRange } from './getStepRange';
-export { hasDocAsParent } from './hasDocAsParent';
-export { hasVisibleContent } from './hasVisibleContent';
-export { isEmptyDocument } from './isEmptyDocument';
-export { isSelectionEndOfParagraph } from './isSelectionEndOfParagraph';
+export { nodesBetweenChanged, getStepRange, isEmptyDocument, hasDocAsParent, bracketTyped, hasVisibleContent, isSelectionEndOfParagraph, getChangedNodes } from './document';
 
 /**
  * @private
@@ -178,16 +168,10 @@ export { isSelectionEndOfParagraph } from './isSelectionEndOfParagraph';
  * Use `@atlaskit/editor-common/process-raw-value` entry-point instead.
  */
 export { processRawValue } from './processRawValue';
-export { calculateSnapPoints } from './calculateSnapPoints';
-export { floatingLayouts } from './floatingLayouts';
-export { isRichMediaInsideOfBlockNode } from './isRichMediaInsideOfBlockNode';
-export { nonWrappedLayouts } from './nonWrappedLayouts';
-export { alignAttributes } from './rich-media-utils';
+export { floatingLayouts, isRichMediaInsideOfBlockNode, calculateSnapPoints, alignAttributes, nonWrappedLayouts } from './rich-media-utils';
 export { sanitizeNodeForPrivacy } from './filter/privacy-filter';
-export { canRenderDatasource } from './datasource';
-export { getDatasourceType } from './getDatasourceType';
-export { filterCommand, isEmptySelectionAtStart, isEmptySelectionAtEnd, deleteEmptyParagraphAndMoveBlockUp, insertNewLineWithAnalytics, createNewParagraphAbove, createNewParagraphBelow, createParagraphNear, walkNextNode, walkPrevNode } from './commands';
-export { insertContentDeleteRange } from './insertContentDeleteRange';
+export { canRenderDatasource, getDatasourceType } from './datasource';
+export { filterCommand, isEmptySelectionAtStart, isEmptySelectionAtEnd, insertContentDeleteRange, deleteEmptyParagraphAndMoveBlockUp, insertNewLineWithAnalytics, createNewParagraphAbove, createNewParagraphBelow, createParagraphNear, walkNextNode, walkPrevNode } from './commands';
 export { GUTTER_SELECTOR, GUTTER_SIZE_IN_PX, GUTTER_SIZE_MOBILE_IN_PX } from './scroll-gutter';
 
 /**
@@ -206,8 +190,7 @@ export function shallowEqual(obj1 = {}, obj2 = {}) {
   const keys2 = Object.keys(obj2);
   return keys1.length === keys2.length && keys1.reduce((acc, key) => acc && obj1[key] === obj2[key], true);
 }
-export { createRule } from './createRule';
-export { inputRuleWithAnalytics, createWrappingJoinRule } from './input-rules';
+export { inputRuleWithAnalytics, createWrappingJoinRule, createRule } from './input-rules';
 export function isSelectionInsideLastNodeInDocument(selection) {
   const docNode = selection.$anchor.node(0);
   const rootNode = selection.$anchor.node(1);
@@ -380,5 +363,4 @@ export { calculateToolbarPositionAboveSelection, calculateToolbarPositionOnCellS
 export { findNodePosByLocalIds } from './nodes-by-localIds';
 export { getPageElementCounts } from './page-element-counts';
 export { withFeatureFlaggedComponent } from './withFeatureFlaggedComponent';
-export { isNodeTypeValidChildOf } from './isNodeTypeValidChildOf';
-export { isNodeOfSameBaseType, getBaseNodeTypeName } from './node-type-utils';
+export { isNodeOfSameBaseType, getBaseNodeTypeName, isNodeTypeValidChildOf } from './node-type-utils';

package/dist/es2019/utils/input-rules.js

@@ -1,6 +1,6 @@
 import { canJoin, findWrapping } from '@atlaskit/editor-prosemirror/transform';
+import { closeHistory } from '@atlaskit/prosemirror-history';
 import { JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST } from '../analytics';
-import { createRule } from './createRule';
 // Roughly based on atlassian-frontend/packages/editor/editor-core/src/utils/input-rules.ts but with the Editor Analytics API that's injected in plugins
 export const inputRuleWithAnalytics = (getPayload, analyticsApi) => {
   return originalRule => {
@@ -53,5 +53,13 @@ export const createWrappingJoinRule = ({
   };
   return createRule(match, handler);
 };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { createRule } from './createRule';
+export const createRule = (match, handler, allowsBackwardMatch = false) => {
+  return {
+    match,
+    handler,
+    onHandlerApply: (_state, tr) => {
+      closeHistory(tr);
+    },
+    allowsBackwardMatch
+  };
+};

package/dist/es2019/utils/insert-node-into-ordered-list.js

@@ -1,7 +1,7 @@
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType, findParentNodeOfTypeClosestToPos, safeInsert } from '@atlaskit/editor-prosemirror/utils';
-import { isListNode } from './isListNode';
+import { isListNode } from './list';
 
 // Taken from `editor-plugin-content-insertion`
 function setSelectionToValidTextNode(tr, node, from) {

package/dist/es2019/utils/list.js

@@ -1,8 +1,21 @@
 // File has been copied to packages/editor/editor-plugin-ai/src/provider/prosemirror-transformer/utils/list.ts
 // If changes are made to this file, please make the same update in the linked file.
 
-import { resolveOrder } from './resolveOrder';
 export const DEFAULT_ORDER = 1;
+
+// resolve "order" to a safe, 0+ integer, otherwise return undefined
+// Note: Any changes to this function should also be made to "resolveStart"
+// in packages/editor/adf-schema/src/schema/nodes/ordered-list.ts
+export const resolveOrder = order => {
+  const num = Number(order);
+  if (Number.isNaN(num)) {
+    return;
+  }
+  if (num < 0) {
+    return;
+  }
+  return Math.floor(Math.max(num, 0));
+};
 export const getOrderFromOrderedListNode = orderedListNode => {
   var _orderedListNode$attr, _resolveOrder;
   const order = orderedListNode === null || orderedListNode === void 0 ? void 0 : (_orderedListNode$attr = orderedListNode.attrs) === null || _orderedListNode$attr === void 0 ? void 0 : _orderedListNode$attr.order;
@@ -15,13 +28,15 @@ export const getItemCounterDigitsSize = options => {
   const largestCounter = order + (itemsCount - 1);
   return (_String = String(largestCounter)) === null || _String === void 0 ? void 0 : (_String$split = _String.split('.')) === null || _String$split === void 0 ? void 0 : (_String$split$ = _String$split[0]) === null || _String$split$ === void 0 ? void 0 : _String$split$.length;
 };
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { resolveOrder } from './resolveOrder';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isListNode } from './isListNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isParagraphNode } from './isParagraphNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isListItemNode } from './isListItemNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isBulletList } from './isBulletList';
+export function isListNode(node) {
+  return Boolean(node && node.type && ['orderedList', 'bulletList'].includes(node.type.name));
+}
+export function isParagraphNode(node) {
+  return Boolean(node && node.type && 'paragraph' === node.type.name);
+}
+export function isListItemNode(node) {
+  return Boolean(node && node.type && 'listItem' === node.type.name);
+}
+export function isBulletList(node) {
+  return Boolean(node && node.type && 'bulletList' === node.type.name);
+}

package/dist/es2019/utils/node-type-utils.js

@@ -1,3 +1,4 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
 /**
  * Returns the base name of a node type, stripping known variant suffixes.
  */
@@ -18,4 +19,20 @@ export function getBaseNodeTypeName(nodeType) {
 export function isNodeOfSameBaseType(a, b) {
   return getBaseNodeTypeName(a) === getBaseNodeTypeName(b);
 }
-// eslint-disable-next-line @atlaskit/editor/no-re-export
+
+/**
+ * Checks if a node type is a valid child of a parent node by creating a minimal valid
+ * instance and validating it against the parent's content expression. Unlike ProseMirror's
+ * canReplaceWith, this checks general type compatibility without requiring a specific insertion index.
+ */
+export function isNodeTypeValidChildOf(childTypeName, parentNode, schema) {
+  const childType = schema.nodes[childTypeName];
+  if (!childType) {
+    return false;
+  }
+  const candidate = childType.createAndFill();
+  if (!candidate) {
+    return false;
+  }
+  return parentNode.type.validContent(Fragment.from(candidate));
+}

package/dist/es2019/utils/nodes.js

@@ -1,6 +1,33 @@
 import { JSONTransformer } from '@atlaskit/editor-json-transformer';
-import { SelectedState } from './SelectedState';
-import { validNode } from './validNode';
+import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+/**
+ * Finds all top level nodes affected by the transaction
+ * Uses from/to positions in transaction's steps to work out which nodes will
+ * be changed by the transaction
+ */
+export const findChangedNodesFromTransaction = tr => {
+  const nodes = [];
+  const steps = tr.steps || [];
+  steps.forEach(step => {
+    step.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+      tr.doc.nodesBetween(newStart, Math.min(newEnd, tr.doc.content.size), node => {
+        if (!nodes.find(n => n === node)) {
+          nodes.push(node);
+        }
+        return false;
+      });
+    });
+  });
+  return nodes;
+};
+export const validNode = node => {
+  try {
+    node.check(); // this will throw an error if the node is invalid
+  } catch (error) {
+    return false;
+  }
+  return true;
+};
 
 /** Validates prosemirror nodes, and returns true only if all nodes are valid */
 export const validateNodes = nodes => nodes.every(validNode);
@@ -8,6 +35,11 @@ export const isType = (node, type) => type && node && node.type === type;
 export const isParagraph = (node, schema) => isType(node, schema.nodes.paragraph);
 export const isText = (node, schema) => isType(node, schema.nodes.text);
 export const isLinkMark = (node, schema) => isType(node, schema.marks.link);
+export let SelectedState = /*#__PURE__*/function (SelectedState) {
+  SelectedState[SelectedState["selectedInRange"] = 0] = "selectedInRange";
+  SelectedState[SelectedState["selectedInside"] = 1] = "selectedInside";
+  return SelectedState;
+}({});
 
 /**
  * Returns if the current selection from achor-head is selecting the node.
@@ -34,22 +66,54 @@ export const isNodeSelectedOrInRange = (anchorPosition, headPosition, nodePositi
   }
   return null;
 };
+
+/**
+ * Checks if a particular node fragment is supported in the parent
+ * @param state EditorState
+ * @param fragment The fragment to be checked for
+ */
+export const isSupportedInParent = (state, fragment, currentAppearance) => {
+  const depth = currentAppearance === 'embed' || currentAppearance === 'block' ? undefined : -1;
+  const parent = state.selection.$from.node(depth);
+  return parent && parent.type.validContent(fragment);
+};
+
+/**
+ * Checks if the passed in node is a media node
+ * Includes media, mediaInline, mediaGroup, mediaSingle
+ * @param node The PM node to be checked
+ */
+export const isMediaNode = node => {
+  return ['media', 'mediaInline', 'mediaGroup', 'mediaSingle'].includes(node.type.name);
+};
+
+/**
+ * Checks if the node before selection is a media node
+ * If there is no node before, checks the node before the parent node
+ * Includes media, mediaInline, mediaGroup, mediaSingle
+ * @param $pos The position of the selection
+ * @param state The editor state
+ */
+export const isNodeBeforeMediaNode = ($pos, state) => {
+  let nodeBefore = $pos.nodeBefore;
+  if (!nodeBefore) {
+    const depthOfParent = $pos.depth - 1 || 1;
+    const parentNode = findParentNodeOfType([state.schema.nodes[`${$pos.node(depthOfParent).type.name}`]])(state.selection);
+    const resolvedPosOfParentNode = parentNode ? state.tr.doc.resolve(parentNode.pos) : undefined;
+    const nodeBeforeParent = resolvedPosOfParentNode && resolvedPosOfParentNode.pos < state.doc.nodeSize ? resolvedPosOfParentNode.nodeBefore : undefined;
+    if (nodeBeforeParent) {
+      nodeBefore = nodeBeforeParent;
+    }
+  }
+  if (nodeBefore) {
+    return ['media', 'mediaInline', 'mediaGroup', 'mediaSingle'].includes(nodeBefore.type.name);
+  }
+  return false;
+};
 const transformer = new JSONTransformer();
 export function toJSON(node) {
   return transformer.encode(node);
 }
 export function nodeToJSON(node) {
   return transformer.encodeNode(node);
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { findChangedNodesFromTransaction } from './findChangedNodesFromTransaction';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { validNode } from './validNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { SelectedState } from './SelectedState';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isSupportedInParent } from './isSupportedInParent';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isMediaNode } from './isMediaNode';
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isNodeBeforeMediaNode } from './isNodeBeforeMediaNode';
+}

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

@@ -1,7 +1,24 @@
 import { defaultSchema } from '@atlaskit/adf-schema/schema-default';
 import { DOMParser } from '@atlaskit/editor-prosemirror/model';
-import { getNestingRulesFromSchema } from './getNestingRulesFromSchema';
 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;
@@ -159,5 +176,4 @@ export const parseHTMLTextContent = html => {
     version: 1,
     content: blocks.length > 0 ? blocks : [createParagraph()]
   };
-};
-// eslint-disable-next-line @atlaskit/editor/no-re-export
+};

package/dist/es2019/utils/performance/is-performance-api-available.js

@@ -1,4 +1,3 @@
-import { isPerformanceObserverAvailable } from './isPerformanceObserverAvailable';
 let hasRequiredPerformanceAPIs;
 export function isPerformanceAPIAvailable() {
   if (hasRequiredPerformanceAPIs === undefined) {
@@ -9,8 +8,9 @@ export function isPerformanceAPIAvailable() {
   }
   return hasRequiredPerformanceAPIs;
 }
+export function isPerformanceObserverAvailable() {
+  return !!(typeof window !== 'undefined' && 'PerformanceObserver' in window);
+}
 export function isPerformanceObserverLongTaskAvailable() {
   return isPerformanceObserverAvailable() && PerformanceObserver.supportedEntryTypes && PerformanceObserver.supportedEntryTypes.includes('longtask');
-}
-// eslint-disable-next-line @atlaskit/editor/no-re-export
-export { isPerformanceObserverAvailable } from './isPerformanceObserverAvailable';
+}