@atlaskit/editor-common 72.2.0 → 72.2.2

package/dist/cjs/utils/track-unsupported-content.js

@@ -1,28 +1,20 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.trackUnsupportedContentTooltipDisplayedFor = exports.fireUnsupportedEvent = exports.findAndTrackUnsupportedContentNodes = void 0;
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _analytics = require("../analytics");
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 var whitelistedAttributes = ['align', 'annotationType', 'extensionKey', 'extensionType', 'layout', 'type', 'localId', 'mode', 'language', 'timestamp', 'state', 'originalWidth', 'originalHeight', 'height', 'width', 'shortName', 'level', 'userType', 'order', 'panelType', 'color', 'style', 'isNumberColumnEnabled', 'colspan', 'rowspan', 'colwidth', 'background'];
-
 function concatAncestorHierarchy(node, ancestoryHierarchy) {
-  var name = node.type.name; // Space concatenator used to reduce analytics payload size
-
+  var name = node.type.name;
+  // Space concatenator used to reduce analytics payload size
   return ancestoryHierarchy ? "".concat(ancestoryHierarchy, " ").concat(name) : name;
 }
-
 var sanitizeMarks = function sanitizeMarks() {
   var marks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   var sanitizedMarks = [];
@@ -38,7 +30,6 @@ var sanitizeMarks = function sanitizeMarks() {
   });
   return sanitizedMarks;
 };
-
 var sanitizeAttributes = function sanitizeAttributes() {
   var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var sanitizedAttrs = Object.assign({}, attrs);
@@ -49,7 +40,6 @@ var sanitizeAttributes = function sanitizeAttributes() {
   });
   return sanitizedAttrs;
 };
-
 var trackUnsupportedContentTooltipActionFor = function trackUnsupportedContentTooltipActionFor(action, dispatchAnalyticsEvent, unsupportedContentType, originalNodeType) {
   dispatchAnalyticsEvent({
     action: action,
@@ -61,28 +51,24 @@ var trackUnsupportedContentTooltipActionFor = function trackUnsupportedContentTo
     }
   });
 };
-
 var findAndTrackUnsupportedContentNodes = function findAndTrackUnsupportedContentNodes(node, schema, dispatchAnalyticsEvent) {
   var ancestorHierarchy = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
   var nodeType = node.type,
-      nodeMarks = node.marks;
+    nodeMarks = node.marks;
   var _schema$marks = schema.marks,
-      unsupportedMark = _schema$marks.unsupportedMark,
-      unsupportedNodeAttribute = _schema$marks.unsupportedNodeAttribute;
+    unsupportedMark = _schema$marks.unsupportedMark,
+    unsupportedNodeAttribute = _schema$marks.unsupportedNodeAttribute;
   var _schema$nodes = schema.nodes,
-      unsupportedInline = _schema$nodes.unsupportedInline,
-      unsupportedBlock = _schema$nodes.unsupportedBlock;
+    unsupportedInline = _schema$nodes.unsupportedInline,
+    unsupportedBlock = _schema$nodes.unsupportedBlock;
   var parentType = ancestorHierarchy.split(' ').pop() || '';
-
   if (nodeMarks.length) {
     nodeMarks.forEach(function (mark) {
       if (mark.type === unsupportedMark) {
         var _ref = mark.attrs || {},
-            originalValue = _ref.originalValue;
-
+          originalValue = _ref.originalValue;
         var _ref2 = originalValue || {},
-            type = _ref2.type;
-
+          type = _ref2.type;
         var unsupportedNode = {
           type: type || '',
           ancestry: ancestorHierarchy,
@@ -93,8 +79,7 @@ var findAndTrackUnsupportedContentNodes = function findAndTrackUnsupportedConten
         fireUnsupportedEvent(dispatchAnalyticsEvent, _analytics.ACTION_SUBJECT_ID.UNSUPPORTED_MARK, unsupportedNode);
       } else if (mark.type === unsupportedNodeAttribute) {
         var _ref3 = mark.attrs || {},
-            unsupported = _ref3.unsupported;
-
+          unsupported = _ref3.unsupported;
         var _unsupportedNodeAttribute = {
           type: nodeType.name || '',
           ancestry: ancestorHierarchy,
@@ -106,20 +91,15 @@ var findAndTrackUnsupportedContentNodes = function findAndTrackUnsupportedConten
       }
     });
   }
-
   if (nodeType === unsupportedInline || nodeType === unsupportedBlock) {
     var _ref4 = node.attrs || {},
-        originalValue = _ref4.originalValue;
-
+      originalValue = _ref4.originalValue;
     var _ref5 = originalValue || [],
-        marks = _ref5.marks;
-
+      marks = _ref5.marks;
     var _ref6 = originalValue || {},
-        attrs = _ref6.attrs;
-
+      attrs = _ref6.attrs;
     var _ref7 = originalValue || {},
-        type = _ref7.type;
-
+      type = _ref7.type;
     var unsupportedNode = {
       type: type || '',
       ancestry: ancestorHierarchy,
@@ -136,9 +116,7 @@ var findAndTrackUnsupportedContentNodes = function findAndTrackUnsupportedConten
     });
   }
 };
-
 exports.findAndTrackUnsupportedContentNodes = findAndTrackUnsupportedContentNodes;
-
 var fireUnsupportedEvent = function fireUnsupportedEvent(dispatchAnalyticsEvent, actionSubjectId, unsupportedNode, errorCode) {
   var sanitizedAttrs = sanitizeAttributes(unsupportedNode.attrs);
   var sanitizedMarks = sanitizeMarks(unsupportedNode.marks);
@@ -162,11 +140,8 @@ var fireUnsupportedEvent = function fireUnsupportedEvent(dispatchAnalyticsEvent,
   };
   dispatchAnalyticsEvent(payload);
 };
-
 exports.fireUnsupportedEvent = fireUnsupportedEvent;
-
 var trackUnsupportedContentTooltipDisplayedFor = function trackUnsupportedContentTooltipDisplayedFor(dispatchAnalyticsEvent, unsupportedContentType, originalNodeType) {
   trackUnsupportedContentTooltipActionFor(_analytics.ACTION.UNSUPPORTED_TOOLTIP_VIEWED, dispatchAnalyticsEvent, unsupportedContentType, originalNodeType);
 };
-
 exports.trackUnsupportedContentTooltipDisplayedFor = trackUnsupportedContentTooltipDisplayedFor;

package/dist/cjs/utils/traversor.js

@@ -1,30 +1,23 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var ADFTraversor = /*#__PURE__*/function () {
   function ADFTraversor(doc) {
     (0, _classCallCheck2.default)(this, ADFTraversor);
     (0, _defineProperty2.default)(this, "subscribers", new Map());
     this.doc = doc;
   }
-
   (0, _createClass2.default)(ADFTraversor, [{
     key: "subscribe",
     value: function subscribe(type, callback) {
       var callbacks = this.subscribers.get(type);
-
       if (!callbacks) {
         this.subscribers.set(type, [callback]);
       } else {
@@ -37,22 +30,16 @@ var ADFTraversor = /*#__PURE__*/function () {
       if (!this.doc || !Array.isArray(this.doc.content)) {
         return;
       }
-
       var candidates = this.doc.content.slice(0);
-
       while (candidates.length) {
         var _node = candidates.shift();
-
         if (Array.isArray(_node.content)) {
           candidates = candidates.concat(_node.content);
         }
-
         var callbacks = this.subscribers.get(_node.type);
-
         if (!callbacks) {
           continue;
         }
-
         for (var i = 0; i < callbacks.length; i++) {
           callbacks[i](_node);
         }
@@ -61,6 +48,5 @@ var ADFTraversor = /*#__PURE__*/function () {
   }]);
   return ADFTraversor;
 }();
-
 var _default = ADFTraversor;
 exports.default = _default;

package/dist/cjs/utils/unsupportedContent/get-unsupported-content-level-data.js

@@ -4,43 +4,34 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getUnsupportedContentLevelData = exports.UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS = exports.UNSUPPORTED_CONTENT_LEVEL_SEVERITY = void 0;
-
 var _traverse = require("@atlaskit/adf-utils/traverse");
-
 var UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
 exports.UNSUPPORTED_CONTENT_LEVEL_SEVERITY = UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
-
 (function (UNSUPPORTED_CONTENT_LEVEL_SEVERITY) {
   UNSUPPORTED_CONTENT_LEVEL_SEVERITY["NORMAL"] = "normal";
   UNSUPPORTED_CONTENT_LEVEL_SEVERITY["DEGRADED"] = "degraded";
   UNSUPPORTED_CONTENT_LEVEL_SEVERITY["BLOCKING"] = "blocking";
 })(UNSUPPORTED_CONTENT_LEVEL_SEVERITY || (exports.UNSUPPORTED_CONTENT_LEVEL_SEVERITY = UNSUPPORTED_CONTENT_LEVEL_SEVERITY = {}));
-
 var UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS = {
   DEGRADED: 10,
   BLOCKING: 25
 };
 exports.UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS = UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS;
-
 var buildUnsupportedContentLevelThresholds = function buildUnsupportedContentLevelThresholds(customThresholds) {
   return {
     degraded: (customThresholds === null || customThresholds === void 0 ? void 0 : customThresholds.degraded) || UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS.DEGRADED,
     blocking: (customThresholds === null || customThresholds === void 0 ? void 0 : customThresholds.blocking) || UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS.BLOCKING
   };
 };
-
 var countSupportedUnsupportedNodes = function countSupportedUnsupportedNodes(validDocument) {
   var unsupportedNodes = 0;
   var supportedNodes = 0;
   (0, _traverse.traverse)(validDocument, {
     any: function any(node) {
       var unsupportedNodeTypes = ['unsupportedInline', 'unsupportedBlock', 'confluenceUnsupportedInline', 'confluenceUnsupportedBlock'];
-
       if (unsupportedNodeTypes.includes(node.type)) {
         var _node$attrs;
-
         var originalNode = (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.originalValue;
-
         if (originalNode) {
           // start an independent traversal for the purpose of counting
           // unsupported content nodes (with nested children contributing towards
@@ -50,10 +41,9 @@ var countSupportedUnsupportedNodes = function countSupportedUnsupportedNodes(val
               unsupportedNodes++;
             }
           });
-        } // force the parent traversal (which is counting supported content nodes)
+        }
+        // force the parent traversal (which is counting supported content nodes)
         // to skip traversal/counting of nested children of the unsupported nodes
-
-
         return false;
       } else {
         supportedNodes++;
@@ -65,18 +55,16 @@ var countSupportedUnsupportedNodes = function countSupportedUnsupportedNodes(val
     supportedNodes: supportedNodes
   };
 };
-
 var mapUnsupportedContentLevelToSeverity = function mapUnsupportedContentLevelToSeverity(unsupportedContentLevelPercent, thresholds) {
   if (thresholds.degraded <= unsupportedContentLevelPercent && unsupportedContentLevelPercent < thresholds.blocking) {
     return UNSUPPORTED_CONTENT_LEVEL_SEVERITY.DEGRADED;
   }
-
   if (thresholds.blocking <= unsupportedContentLevelPercent) {
     return UNSUPPORTED_CONTENT_LEVEL_SEVERITY.BLOCKING;
   }
-
   return UNSUPPORTED_CONTENT_LEVEL_SEVERITY.NORMAL;
 };
+
 /**
  * When given a valid ADF document, this function will return an information
  * object about the level of unsupported content in the document including:
@@ -104,13 +92,10 @@ var mapUnsupportedContentLevelToSeverity = function mapUnsupportedContentLevelTo
  * ```
  *
  */
-
-
 var getUnsupportedContentLevelData = function getUnsupportedContentLevelData(validDocument, customThresholds) {
   var _countSupportedUnsupp = countSupportedUnsupportedNodes(validDocument),
-      unsupportedNodes = _countSupportedUnsupp.unsupportedNodes,
-      supportedNodes = _countSupportedUnsupp.supportedNodes;
-
+    unsupportedNodes = _countSupportedUnsupp.unsupportedNodes,
+    supportedNodes = _countSupportedUnsupp.supportedNodes;
   var thresholds = buildUnsupportedContentLevelThresholds(customThresholds);
   var percentage = Math.round(unsupportedNodes / (unsupportedNodes + supportedNodes) * 100);
   var severity = mapUnsupportedContentLevelToSeverity(percentage, thresholds);
@@ -123,5 +108,4 @@ var getUnsupportedContentLevelData = function getUnsupportedContentLevelData(val
     }
   };
 };
-
 exports.getUnsupportedContentLevelData = getUnsupportedContentLevelData;

package/dist/cjs/utils/validate-using-spec.js

@@ -5,31 +5,23 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.validationErrorHandler = exports.validateADFEntity = exports.UNSUPPORTED_NODE_ATTRIBUTE = void 0;
 exports.wrapWithUnsupported = wrapWithUnsupported;
-
 var _validator = require("@atlaskit/adf-utils/validator");
-
 var _analytics = require("../analytics");
-
 var _trackUnsupportedContent = require("./track-unsupported-content");
-
 var UNSUPPORTED_NODE_ATTRIBUTE = 'unsupportedNodeAttribute';
 exports.UNSUPPORTED_NODE_ATTRIBUTE = UNSUPPORTED_NODE_ATTRIBUTE;
-
 var errorCallbackFor = function errorCallbackFor(marks, validate, dispatchAnalyticsEvent) {
   return function (entity, error, options) {
     return validationErrorHandler(entity, error, options, marks, validate, dispatchAnalyticsEvent);
   };
 };
-
 var validationErrorHandler = function validationErrorHandler(entity, error, options, marks, validate, dispatchAnalyticsEvent) {
   if (entity && entity.type === UNSUPPORTED_NODE_ATTRIBUTE) {
     return entity;
   }
-
   if (options.isMark) {
     return wrapWithUnsupported(error.meta, 'mark');
   }
-
   if (options.isNodeAttribute) {
     var entityType = entity && entity.type ? entity.type : undefined;
     return {
@@ -42,25 +34,23 @@ var validationErrorHandler = function validationErrorHandler(entity, error, opti
       }
     };
   }
-
   if (entity && marks.indexOf(entity.type) > -1) {
     return;
   }
+
   /**
    * There's a inconsistency between ProseMirror and ADF.
    * `content` is actually optional in ProseMirror.
    * And, also empty `text` node is not valid.
    */
-
-
   if (error.code === 'MISSING_PROPERTIES' && entity.type === 'paragraph') {
     return {
       type: 'paragraph',
       content: []
     };
-  } // TODO: We can repair missing content like `panel` without a `paragraph`.
-
+  }
 
+  // TODO: We can repair missing content like `panel` without a `paragraph`.
   if (error.code === 'INVALID_CONTENT_LENGTH') {
     if (error.meta && options.allowUnsupportedBlock && entity.content) {
       return getEntityForInvalidContentLength(error, entity, validate, marks, dispatchAnalyticsEvent);
@@ -71,27 +61,20 @@ var validationErrorHandler = function validationErrorHandler(entity, error, opti
       }
     }
   }
-
   if (options.allowUnsupportedBlock) {
     return wrapWithUnsupported(entity);
   }
-
   if (options.allowUnsupportedInline) {
     return wrapWithUnsupported(entity, 'inline');
   }
-
   if (dispatchAnalyticsEvent) {
     trackValidationError(dispatchAnalyticsEvent, error, entity);
   }
-
   return entity;
 };
-
 exports.validationErrorHandler = validationErrorHandler;
-
 function getEntityForInvalidContentLength(error, entity, validate, marks, dispatchAnalyticsEvent) {
   var meta = error.meta;
-
   if (meta.type === 'maximum') {
     entity.content = entity.content.filter(function (x) {
       return !!x;
@@ -99,27 +82,22 @@ function getEntityForInvalidContentLength(error, entity, validate, marks, dispat
       return index >= meta.requiredLength && child.type !== 'unsupportedBlock' ? wrapWithUnsupported(child) : validate(child, errorCallbackFor(marks, validate, dispatchAnalyticsEvent)).entity;
     });
   }
-
   if (meta.type === 'minimum') {
     if (entity.content.length === 0) {
       return wrapWithUnsupported(entity);
     }
-
     entity.content = entity.content.filter(function (x) {
       return !!x;
     }).map(function (child) {
       return child.type !== 'unsupportedBlock' ? wrapWithUnsupported(child) : child;
     });
   }
-
   return entity;
 }
-
 function trackValidationError(dispatchAnalyticsEvent, error, entity) {
   if (!dispatchAnalyticsEvent) {
     return;
   }
-
   (0, _trackUnsupportedContent.fireUnsupportedEvent)(dispatchAnalyticsEvent, _analytics.ACTION_SUBJECT_ID.UNSUPPORTED_ERROR, {
     type: entity.type || '',
     ancestry: entity.ancestorHierarchy || '',
@@ -128,7 +106,6 @@ function trackValidationError(dispatchAnalyticsEvent, error, entity) {
     attrs: entity.attrs || {}
   }, error.code);
 }
-
 var validateADFEntity = function validateADFEntity(schema, node, dispatchAnalyticsEvent) {
   var nodes = Object.keys(schema.nodes);
   var marks = Object.keys(schema.marks);
@@ -139,33 +116,25 @@ var validateADFEntity = function validateADFEntity(schema, node, dispatchAnalyti
     type: 'doc',
     content: []
   };
-
   var _validate = validate(node, errorCallbackFor(marks, validate, dispatchAnalyticsEvent)),
-      _validate$entity = _validate.entity,
-      entity = _validate$entity === void 0 ? emptyDoc : _validate$entity;
-
+    _validate$entity = _validate.entity,
+    entity = _validate$entity === void 0 ? emptyDoc : _validate$entity;
   return entity;
 };
-
 exports.validateADFEntity = validateADFEntity;
-
 function wrapWithUnsupported(originalValue) {
   var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'block';
   var unsupportedNodeType;
-
   switch (type) {
     case 'inline':
       unsupportedNodeType = 'unsupportedInline';
       break;
-
     case 'mark':
       unsupportedNodeType = 'unsupportedMark';
       break;
-
     default:
       unsupportedNodeType = 'unsupportedBlock';
   }
-
   return {
     type: unsupportedNodeType,
     attrs: {