@atlaskit/editor-common 72.1.2 → 72.2.1

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

@@ -1,36 +1,29 @@
 import { traverse } from '@atlaskit/adf-utils/traverse';
 export let 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 || (UNSUPPORTED_CONTENT_LEVEL_SEVERITY = {}));
-
 export const UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS = {
   DEGRADED: 10,
   BLOCKING: 25
 };
-
 const 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
   };
 };
-
 const countSupportedUnsupportedNodes = validDocument => {
   let unsupportedNodes = 0;
   let supportedNodes = 0;
   traverse(validDocument, {
     any: node => {
       const unsupportedNodeTypes = ['unsupportedInline', 'unsupportedBlock', 'confluenceUnsupportedInline', 'confluenceUnsupportedBlock'];
-
       if (unsupportedNodeTypes.includes(node.type)) {
         var _node$attrs;
-
         const 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
@@ -40,10 +33,9 @@ const countSupportedUnsupportedNodes = validDocument => {
               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++;
@@ -55,18 +47,16 @@ const countSupportedUnsupportedNodes = validDocument => {
     supportedNodes
   };
 };
-
 const 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:
@@ -94,8 +84,6 @@ const mapUnsupportedContentLevelToSeverity = (unsupportedContentLevelPercent, th
  * ```
  *
  */
-
-
 export const getUnsupportedContentLevelData = (validDocument, customThresholds) => {
   const {
     unsupportedNodes,

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

@@ -2,22 +2,18 @@ import { validator } from '@atlaskit/adf-utils/validator';
 import { ACTION_SUBJECT_ID } from '../analytics';
 export const UNSUPPORTED_NODE_ATTRIBUTE = 'unsupportedNodeAttribute';
 import { fireUnsupportedEvent } from './track-unsupported-content';
-
 const errorCallbackFor = (marks, validate, dispatchAnalyticsEvent) => {
   return (entity, error, options) => {
     return validationErrorHandler(entity, error, options, marks, validate, dispatchAnalyticsEvent);
   };
 };
-
 export const 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) {
     const entityType = entity && entity.type ? entity.type : undefined;
     return {
@@ -30,25 +26,23 @@ export const validationErrorHandler = (entity, error, options, marks, validate,
       }
     };
   }
-
   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);
@@ -59,49 +53,38 @@ export const validationErrorHandler = (entity, error, options, marks, validate,
       }
     }
   }
-
   if (options.allowUnsupportedBlock) {
     return wrapWithUnsupported(entity);
   }
-
   if (options.allowUnsupportedInline) {
     return wrapWithUnsupported(entity, 'inline');
   }
-
   if (dispatchAnalyticsEvent) {
     trackValidationError(dispatchAnalyticsEvent, error, entity);
   }
-
   return entity;
 };
-
 function getEntityForInvalidContentLength(error, entity, validate, marks, dispatchAnalyticsEvent) {
   const meta = error.meta;
-
   if (meta.type === 'maximum') {
     entity.content = entity.content.filter(x => !!x).map((child, index) => {
       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(x => !!x).map(child => {
       return child.type !== 'unsupportedBlock' ? wrapWithUnsupported(child) : child;
     });
   }
-
   return entity;
 }
-
 function trackValidationError(dispatchAnalyticsEvent, error, entity) {
   if (!dispatchAnalyticsEvent) {
     return;
   }
-
   fireUnsupportedEvent(dispatchAnalyticsEvent, ACTION_SUBJECT_ID.UNSUPPORTED_ERROR, {
     type: entity.type || '',
     ancestry: entity.ancestorHierarchy || '',
@@ -110,7 +93,6 @@ function trackValidationError(dispatchAnalyticsEvent, error, entity) {
     attrs: entity.attrs || {}
   }, error.code);
 }
-
 export const validateADFEntity = (schema, node, dispatchAnalyticsEvent) => {
   const nodes = Object.keys(schema.nodes);
   const marks = Object.keys(schema.marks);
@@ -128,20 +110,16 @@ export const validateADFEntity = (schema, node, dispatchAnalyticsEvent) => {
 };
 export function wrapWithUnsupported(originalValue, type = 'block') {
   let unsupportedNodeType;
-
   switch (type) {
     case 'inline':
       unsupportedNodeType = 'unsupportedInline';
       break;
-
     case 'mark':
       unsupportedNodeType = 'unsupportedMark';
       break;
-
     default:
       unsupportedNodeType = 'unsupportedBlock';
   }
-
   return {
     type: unsupportedNodeType,
     attrs: {