@atlaskit/editor-common 76.33.2 → 76.35.0

package/dist/cjs/extensibility/extensionNodeView.js

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExtensionNode = void 0;
+exports.default = ExtensionNodeView;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _react = _interopRequireDefault(require("react"));
+var _reactNodeView = _interopRequireDefault(require("../react-node-view"));
+var _Extension = require("./Extension");
+var _ExtensionNodeWrapper = require("./ExtensionNodeWrapper");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+// getInlineNodeViewProducer is a new api to use instead of ReactNodeView
+// when creating inline node views, however, it is difficult to test the impact
+// on selections when migrating inlineExtension to use the new api.
+// The ReactNodeView api will be visited in the second phase of the selections
+// project whilst investigating block nodes. We will revisit the Extension node view there too.
+var ExtensionNode = exports.ExtensionNode = /*#__PURE__*/function (_ReactNodeView) {
+  (0, _inherits2.default)(ExtensionNode, _ReactNodeView);
+  var _super = _createSuper(ExtensionNode);
+  function ExtensionNode() {
+    (0, _classCallCheck2.default)(this, ExtensionNode);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(ExtensionNode, [{
+    key: "ignoreMutation",
+    value: function ignoreMutation(mutation) {
+      // Extensions can perform async operations that will change the DOM.
+      // To avoid having their tree rebuilt, we need to ignore the mutation
+      // for atom based extensions if its not a layout, we need to give
+      // children a chance to recalc
+      return this.node.type.isAtom || mutation.type !== 'selection' && mutation.attributeName !== 'data-layout';
+    }
+  }, {
+    key: "getContentDOM",
+    value: function getContentDOM() {
+      if (this.node.isInline) {
+        return;
+      }
+      var dom = document.createElement('div');
+      dom.className = "".concat(this.node.type.name, "-content-dom-wrapper");
+      return {
+        dom: dom
+      };
+    }
+  }, {
+    key: "render",
+    value: function render(props, forwardRef) {
+      var _props$extensionNodeV;
+      return /*#__PURE__*/_react.default.createElement(_ExtensionNodeWrapper.ExtensionNodeWrapper, {
+        nodeType: this.node.type.name
+      }, /*#__PURE__*/_react.default.createElement(_Extension.Extension, {
+        editorView: this.view,
+        node: this.node,
+        eventDispatcher: this.eventDispatcher
+        // The getPos arg is always a function when used with nodes
+        // the version of the types we use has a union with the type
+        // for marks.
+        // This has been fixed in later versions of the definitly typed
+        // types (and also in prosmirror-views inbuilt types).
+        // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/57384
+        ,
+        getPos: this.getPos,
+        providerFactory: props.providerFactory,
+        handleContentDOMRef: forwardRef,
+        extensionHandlers: props.extensionHandlers,
+        editorAppearance: (_props$extensionNodeV = props.extensionNodeViewOptions) === null || _props$extensionNodeV === void 0 ? void 0 : _props$extensionNodeV.appearance,
+        pluginInjectionApi: props.pluginInjectionApi
+      }));
+    }
+  }]);
+  return ExtensionNode;
+}(_reactNodeView.default);
+function ExtensionNodeView(portalProviderAPI, eventDispatcher, providerFactory, extensionHandlers, extensionNodeViewOptions, pluginInjectionApi) {
+  return function (node, view, getPos) {
+    var hasIntlContext = true;
+    return new ExtensionNode(node, view, getPos, portalProviderAPI, eventDispatcher, {
+      providerFactory: providerFactory,
+      extensionHandlers: extensionHandlers,
+      extensionNodeViewOptions: extensionNodeViewOptions,
+      pluginInjectionApi: pluginInjectionApi
+    }, undefined, undefined, undefined, hasIntlContext).init();
+  };
+}

package/dist/cjs/extensibility/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Extension", {
+  enumerable: true,
+  get: function get() {
+    return _Extension.Extension;
+  }
+});
+Object.defineProperty(exports, "ExtensionComponent", {
+  enumerable: true,
+  get: function get() {
+    return _ExtensionComponent.ExtensionComponent;
+  }
+});
+Object.defineProperty(exports, "ExtensionNode", {
+  enumerable: true,
+  get: function get() {
+    return _extensionNodeView.ExtensionNode;
+  }
+});
+Object.defineProperty(exports, "ExtensionNodeView", {
+  enumerable: true,
+  get: function get() {
+    return _extensionNodeView.default;
+  }
+});
+Object.defineProperty(exports, "ExtensionNodeWrapper", {
+  enumerable: true,
+  get: function get() {
+    return _ExtensionNodeWrapper.ExtensionNodeWrapper;
+  }
+});
+var _ExtensionNodeWrapper = require("./ExtensionNodeWrapper");
+var _Extension = require("./Extension");
+var _extensionNodeView = _interopRequireWildcard(require("./extensionNodeView"));
+var _ExtensionComponent = require("./ExtensionComponent");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/cjs/extensibility/types.js

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

package/dist/cjs/media-inline/media-inline-image-card.js

@@ -26,7 +26,8 @@ var MediaInlineImageCardInternal = exports.MediaInlineImageCardInternal = functi
     isLazy = _ref.isLazy,
     width = _ref.width,
     height = _ref.height,
-    border = _ref.border;
+    border = _ref.border,
+    ssr = _ref.ssr;
   var _useState = (0, _react.useState)(),
     _useState2 = (0, _slicedToArray2.default)(_useState, 2),
     fileState = _useState2[0],
@@ -40,21 +41,23 @@ var MediaInlineImageCardInternal = exports.MediaInlineImageCardInternal = functi
     }),
     formatMessage = _ref2.formatMessage;
   (0, _react.useEffect)(function () {
-    var subscription = mediaClient.file.getFileState(identifier.id, {
-      collectionName: identifier.collectionName
-    }).subscribe({
-      next: function next(fileState) {
-        setFileState(fileState);
-        setSubscribeError(undefined);
-      },
-      error: function error(e) {
-        setSubscribeError(e);
-      }
-    });
-    return function () {
-      subscription.unsubscribe();
-    };
-  }, [identifier.collectionName, identifier.id, mediaClient.file]);
+    if (mediaClient) {
+      var subscription = mediaClient.file.getFileState(identifier.id, {
+        collectionName: identifier.collectionName
+      }).subscribe({
+        next: function next(fileState) {
+          setFileState(fileState);
+          setSubscribeError(undefined);
+        },
+        error: function error(e) {
+          setSubscribeError(e);
+        }
+      });
+      return function () {
+        subscription.unsubscribe();
+      };
+    }
+  }, [identifier, mediaClient]);
   var content = function content(dimensions) {
     if (subscribeError) {
       var isUploading = (fileState === null || fileState === void 0 ? void 0 : fileState.status) === 'uploading';
@@ -79,18 +82,20 @@ var MediaInlineImageCardInternal = exports.MediaInlineImageCardInternal = functi
         message: formatMessage(_mediaInlineCard.messages.unableToLoadContent)
       });
     }
+    var mediaClientConfig = (ssr === null || ssr === void 0 ? void 0 : ssr.config) || (mediaClient === null || mediaClient === void 0 ? void 0 : mediaClient.mediaClientConfig);
     if (!fileState) {
       return (0, _react2.jsx)(_loadingView.InlineImageCardLoadingView, null);
     }
     return (0, _react2.jsx)(_mediaCard.Card, {
-      mediaClientConfig: mediaClient.mediaClientConfig,
+      mediaClientConfig: mediaClientConfig,
       isLazy: isLazy,
       identifier: identifier,
       dimensions: dimensions,
       selectable: true,
       disableOverlay: true,
       selected: isSelected,
-      alt: alt
+      alt: alt,
+      ssr: ssr === null || ssr === void 0 ? void 0 : ssr.mode
     });
   };
   var aspectRatio = (0, _react.useMemo)(function () {
@@ -99,7 +104,7 @@ var MediaInlineImageCardInternal = exports.MediaInlineImageCardInternal = functi
 
   /**
    * scaledDimensions is used to define the correct media size fetched from media service
-   * inline images will only ever be rendererd at a maximum height of H1 and so scaled dimensions
+   * inline images will only ever be rendered at a maximum height of H1 and so scaled dimensions
    * will only ever return a width and height where the height has a maximum height of H1
    */
   var scaledDimension = (0, _react.useMemo)(function () {

package/dist/cjs/monitoring/error.js

@@ -16,7 +16,7 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 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 = "76.33.2";
+var packageVersion = "76.35.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // TODO: Sanitise the URL instead of just removing it
@@ -79,13 +79,14 @@ var logException = exports.logException = /*#__PURE__*/function () {
           hub = getCurrentHub();
           hub.bindClient(client);
           hub.withScope(function (scope) {
+            var _buildInfo;
             scope.setTags(_objectSpread({
               // Jira environment variables
               'jira-bundler': window.BUNDLER_VERSION,
               'jira-variant': window.BUILD_VARIANT,
               'jira-release': window.BUILD_KEY,
               // Confluence environment variables
-              'confluence-frontend-version': window.__buildInfo.FRONTEND_VERSION
+              'confluence-frontend-version': (_buildInfo = window.__buildInfo) === null || _buildInfo === void 0 ? void 0 : _buildInfo.FRONTEND_VERSION
             }, tags));
             // Explicitly remove the breadcrumbs as it's too likely to log UGC/PII to side-step the hub integrations not being respected
             scope.clearBreadcrumbs();

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

@@ -22,7 +22,7 @@ var _templateObject, _templateObject2, _templateObject3;
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /** @jsx jsx */
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "76.33.2";
+var packageVersion = "76.35.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var DropList = /*#__PURE__*/function (_Component) {

package/dist/cjs/utils/index.js

@@ -1028,6 +1028,12 @@ Object.defineProperty(exports, "todayTimestampInUTC", {
     return _date.todayTimestampInUTC;
   }
 });
+Object.defineProperty(exports, "transformNodeIntoListItem", {
+  enumerable: true,
+  get: function get() {
+    return _insertNodeIntoOrderedList.transformNodeIntoListItem;
+  }
+});
 Object.defineProperty(exports, "unwrap", {
   enumerable: true,
   get: function get() {
@@ -1146,6 +1152,7 @@ var _countNodes = require("./count-nodes");
 var _inputRules = require("./input-rules");
 var _dedupe = require("./dedupe");
 var _createWrapSelectionTransaction = require("./create-wrap-selection-transaction");
+var _insertNodeIntoOrderedList = require("./insert-node-into-ordered-list");
 var _wrapSelectionIn = require("./wrap-selection-in");
 var _calculateToolbarPosition = require("./calculate-toolbar-position");
 var _nodesByLocalIds = require("./nodes-by-localIds");

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

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformNodeIntoListItem = transformNodeIntoListItem;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _list = require("./list");
+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 transformNodeIntoListItem(tr, node) {
+  var _tr$doc$nodeAt, _findParentNodeOfType;
+  var _tr$selection = tr.selection,
+    $to = _tr$selection.$to,
+    $from = _tr$selection.$from,
+    to = _tr$selection.to,
+    from = _tr$selection.from;
+  var _tr$doc$type$schema$n = tr.doc.type.schema.nodes,
+    orderedList = _tr$doc$type$schema$n.orderedList,
+    bulletList = _tr$doc$type$schema$n.bulletList,
+    listItem = _tr$doc$type$schema$n.listItem;
+  var startLinePosition = $from.start();
+  var parentStartPosition = $from.depth === 0 ? 0 : $from.before();
+
+  // Setting the start position
+  var startMapped = startLinePosition === from ? parentStartPosition : from;
+
+  // Selected nodes
+  var selectionParentListItemNode = (0, _utils.findParentNodeOfType)(listItem)(tr.selection);
+  var selectionParentListNodeWithPos = (0, _utils.findParentNodeOfType)([bulletList, orderedList])(tr.selection);
+  var selectionParentListNode = selectionParentListNodeWithPos === null || selectionParentListNodeWithPos === void 0 ? void 0 : selectionParentListNodeWithPos.node;
+  if (!selectionParentListNodeWithPos) {
+    return tr;
+  }
+
+  // Offsets
+  var listWrappingOffset = $to.depth - selectionParentListNodeWithPos.depth + 1; // difference in depth between to position and list node
+  var listItemWrappingOffset = $to.depth - selectionParentListNodeWithPos.depth; // difference in depth between to position and list item node
+
+  // Anything to do with nested lists should safeInsert and not be handled here
+  var grandParentListNode = (0, _utils.findParentNodeOfTypeClosestToPos)(tr.doc.resolve(selectionParentListNodeWithPos.pos), [bulletList, orderedList]);
+  var selectionIsInNestedList = !!grandParentListNode;
+  var selectedListItemHasNestedList = false;
+  selectionParentListItemNode === null || selectionParentListItemNode === void 0 || selectionParentListItemNode.node.content.forEach(function (child) {
+    if ((0, _list.isListNode)(child)) {
+      selectedListItemHasNestedList = true;
+    }
+  });
+  if (selectedListItemHasNestedList || selectionIsInNestedList) {
+    return (0, _utils.safeInsert)(node)(tr).scrollIntoView();
+  }
+
+  // Check if node after the insert position is listItem
+  var isNodeAfterInsertPositionIsListItem = ((_tr$doc$nodeAt = tr.doc.nodeAt(to + listItemWrappingOffset)) === null || _tr$doc$nodeAt === void 0 ? void 0 : _tr$doc$nodeAt.type) === listItem;
+  var replaceTo;
+  if (isNodeAfterInsertPositionIsListItem) {
+    replaceTo = to + listItemWrappingOffset;
+  } else if (!isNodeAfterInsertPositionIsListItem) {
+    replaceTo = to;
+  } else {
+    replaceTo = to + listWrappingOffset;
+  }
+
+  // handle the insertion of the slice
+  tr.replaceWith(startMapped, replaceTo, node).scrollIntoView();
+
+  // Get the next list items position (used later to find the split out ordered list)
+  var indexOfNextListItem = $to.indexAfter($to.depth - listItemWrappingOffset);
+  var positionOfNextListItem = tr.doc.resolve(selectionParentListNodeWithPos.pos + 1).posAtIndex(indexOfNextListItem);
+
+  // Find the ordered list node after the pasted content so we can set it's order
+  var mappedPositionOfNextListItem = tr.mapping.map(positionOfNextListItem);
+  if (mappedPositionOfNextListItem > tr.doc.nodeSize) {
+    return tr;
+  }
+  var nodeAfterPastedContentResolvedPos = (0, _utils.findParentNodeOfTypeClosestToPos)(tr.doc.resolve(mappedPositionOfNextListItem), [orderedList]);
+
+  // Work out the new split out lists 'order' (the number it starts from)
+  var originalParentOrderedListNodeOrder = selectionParentListNode === null || selectionParentListNode === void 0 ? void 0 : selectionParentListNode.attrs.order;
+  var numOfListItemsInOriginalList = (_findParentNodeOfType = (0, _utils.findParentNodeOfTypeClosestToPos)(tr.doc.resolve(from - 1), [orderedList])) === null || _findParentNodeOfType === void 0 ? void 0 : _findParentNodeOfType.node.childCount;
+
+  // Set the new split out lists order attribute
+  if (typeof originalParentOrderedListNodeOrder === 'number' && numOfListItemsInOriginalList && nodeAfterPastedContentResolvedPos) {
+    tr.setNodeMarkup(nodeAfterPastedContentResolvedPos.pos, orderedList, _objectSpread(_objectSpread({}, nodeAfterPastedContentResolvedPos.node.attrs), {}, {
+      order: originalParentOrderedListNodeOrder + numOfListItemsInOriginalList
+    }));
+  }
+  return tr;
+}

package/dist/es2019/collab/index.js

@@ -1,3 +1,8 @@
+import { css } from '@emotion/react';
+import { hexToRgba } from '@atlaskit/adf-schema';
+import { relativeFontSizeToBase16 } from '@atlaskit/editor-shared-styles';
+import * as themeColors from '@atlaskit/theme/colors';
+
 // Format of the payload returned by the callback function passed to the collab provider
 // that gets called when syncing with the back-end service fails.
 // Format of the document and its metadata returned from the collab provider
@@ -118,4 +123,52 @@ export let DisconnectReason = /*#__PURE__*/function (DisconnectReason) {
   DisconnectReason["SOCKET_TIMEOUT"] = "SOCKET_TIMEOUT";
   DisconnectReason["UNKNOWN_DISCONNECT"] = "UNKNOWN_DISCONNECT";
   return DisconnectReason;
-}({});
+}({});
+// TODO: https://product-fabric.atlassian.net/browse/DSP-7269
+/* eslint-disable @atlaskit/design-system/ensure-design-token-usage */
+export const colors = [themeColors.R100, themeColors.R300, themeColors.R500, themeColors.Y100, themeColors.Y300, themeColors.Y500, themeColors.G100, themeColors.G300, themeColors.G500, themeColors.T100, themeColors.T300, themeColors.T500, themeColors.B100, themeColors.B300, themeColors.B500, themeColors.P100, themeColors.P300, themeColors.P500, themeColors.N70, themeColors.N200, themeColors.N800].map(solid => ({
+  solid,
+  selection: hexToRgba(solid, 0.2)
+}));
+const telepointerColorStyle = (color, index) => `
+  &.color-${index} {
+    background-color: ${color.selection};
+    &::after {
+      background-color: ${color.solid};
+      color: ${"var(--ds-text-inverse, #fff)"};
+      border-color: ${color.solid};
+    }
+  }
+`;
+export const TELEPOINTER_DIM_CLASS = 'telepointer-dim';
+export const telepointerStyle = css`
+  .ProseMirror .telepointer {
+    position: relative;
+    transition: opacity 200ms;
+
+    &.telepointer-selection {
+      line-height: 1.2;
+      pointer-events: none;
+      user-select: none;
+    }
+
+    &.telepointer-selection-badge::after {
+      content: attr(data-initial);
+      position: absolute;
+      display: block;
+      top: -14px;
+      font-size: ${relativeFontSizeToBase16(9)};
+      padding: ${"var(--ds-space-025, 2px)"};
+      color: ${"var(--ds-text-inverse, white)"};
+      left: -1px;
+      border-radius: 2px 2px 2px 0;
+      line-height: initial;
+    }
+
+    &.${TELEPOINTER_DIM_CLASS} {
+      opacity: 0.2;
+    }
+
+    ${colors.map((color, index) => telepointerColorStyle(color, index))};
+  }
+`;

package/dist/es2019/core-utils/document-logger.js

@@ -0,0 +1,161 @@
+const hash = {
+  nodes: {
+    doc: 'doc',
+    paragraph: 'p',
+    text: 't',
+    bulletList: 'ul',
+    orderedList: 'ol',
+    listItem: 'li',
+    heading: 'h',
+    blockquote: 'blockq',
+    codeBlock: 'codebl',
+    panel: 'pnl',
+    rule: 'rl',
+    hardBreak: 'br',
+    mention: 'ment',
+    emoji: 'emj',
+    image: 'img',
+    caption: 'cap',
+    media: 'media',
+    mediaGroup: 'mediag',
+    mediaSingle: 'medias',
+    plain: 'pln',
+    table: 'table',
+    tableCell: 'td',
+    tableHeader: 'th',
+    tableRow: 'tr',
+    decisionList: 'dl',
+    decisionItem: 'di',
+    taskList: 'tl',
+    taskItem: 'ti',
+    extension: 'ext',
+    inlineExtension: 'exti',
+    bodiedExtension: 'extb',
+    multiBodiedExtension: 'extmbe',
+    extensionFrame: 'extfrm',
+    status: 'sts',
+    placeholder: 'plh',
+    inlineCard: 'cardi',
+    blockCard: 'cardb',
+    embedCard: 'carde',
+    expand: 'exp',
+    nestedExpand: 'expn',
+    unsupportedBlock: 'unsupb',
+    unsupportedInline: 'unsupi',
+    unknownBlock: 'unkb',
+    date: 'date'
+  },
+  marks: {
+    em: 'em',
+    strong: 'strong',
+    code: 'code',
+    strike: 'strike',
+    underline: 'undline',
+    link: 'lnk',
+    subsup: 'subsup',
+    textColor: 'txtclr',
+    unsupportedMark: 'unsupmrk',
+    unsupportedNodeAttribute: 'unsupnattr',
+    annotation: 'anno'
+  }
+};
+function shortHash(type, isMark) {
+  const code = hash[isMark ? 'marks' : 'nodes'][type];
+  return code ? code : type;
+}
+function compactStringifier(node) {
+  var _node$marks;
+  const isContentEmpty = !node.content;
+  const isTextNode = (node === null || node === void 0 ? void 0 : node.type) === 'text';
+  const hasMarks = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.length;
+  const isContentArray = Array.isArray(node.content);
+  const marks = child => {
+    if (hasMarks) {
+      return node.marks.reduce((str, mark) => `${shortHash(mark, true)}(${str})`, child);
+    }
+    return child;
+  };
+  let content;
+  if (isTextNode) {
+    content = String(node.nodeSize);
+  } else if (isContentEmpty) {
+    content = '';
+  } else if (isContentArray) {
+    content = node.content.map(node => compactStringifier(node)).join(',');
+  }
+  return marks(`${shortHash(node.type, false)}(${content})`);
+}
+export const getDocStructure = (doc, options) => {
+  try {
+    const result = getBlockNode(doc, 0);
+    if (options !== null && options !== void 0 && options.compact) {
+      return compactStringifier(result);
+    }
+    return result;
+  } catch (error) {
+    return `Error logging document structure: ${error}`;
+  }
+};
+const getBlockNode = (node, pos) => {
+  const blockNode = {
+    type: node.type.name,
+    pos,
+    nodeSize: node.nodeSize
+  };
+  const content = getBlockNodeContent(node.content, pos);
+  if (content.length > 0) {
+    blockNode.content = content;
+  }
+  const marks = getMarks(node);
+  if (marks.length > 0) {
+    blockNode.marks = marks;
+  }
+  return blockNode;
+};
+const getBlockNodeContent = (node, pos) => {
+  if (!node || !node.content || !node.content.length) {
+    return [];
+  }
+  let blockNodeContent = [];
+  const {
+    content
+  } = node;
+  if (content[0].isBlock) {
+    // children are block nodes
+    let prevNode;
+    blockNodeContent = content.map(node => {
+      pos += prevNode ? prevNode.nodeSize : 1;
+      prevNode = node;
+      return getBlockNode(node, pos);
+    });
+  } else {
+    // children are inline nodes .
+    const result = getInlineNodes(content, pos);
+    blockNodeContent = result.inlineNodes;
+    pos = result.pos;
+  }
+  return blockNodeContent;
+};
+const getInlineNodes = (nodes, pos) => {
+  let inlineNodes = nodes.map(node => {
+    const {
+      nodeSize
+    } = node;
+    const inlineNode = {
+      type: node.type.name,
+      pos,
+      nodeSize
+    };
+    const marks = getMarks(node);
+    if (marks.length > 0) {
+      inlineNode.marks = marks;
+    }
+    pos += nodeSize;
+    return inlineNode;
+  });
+  return {
+    inlineNodes,
+    pos
+  };
+};
+const getMarks = node => node.marks.map(mark => mark.type.name);

package/dist/es2019/core-utils/index.js

@@ -1 +1,2 @@
-export { insideTable } from './inside';
+export { insideTable } from './inside';
+export { getDocStructure } from './document-logger';