@atlaskit/adf-utils 18.0.1 → 18.0.3

package/dist/cjs/validator.js

@@ -15,5 +15,4 @@ Object.defineProperty(exports, "validator", {
     return _validator.validator;
   }
 });
-
 var _validator = require("./validator/validator");

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/adf-utils",
-	"version": "18.0.1",
+	"version": "18.0.3",
 	"sideEffects": false
 }

package/dist/es2019/builders/utils/apply-mark.js

@@ -2,13 +2,11 @@ import { isDuplicateMark, duplicateMarkError } from './is-duplicate-mark';
 import { text } from '../nodes/text';
 export function applyMark(mark, maybeNode) {
   const node = typeof maybeNode === 'string' ? text(maybeNode) : maybeNode;
-
   if (isDuplicateMark(node, mark.type)) {
     // eslint-disable-next-line no-console
     console.error(duplicateMarkError(node, mark.type));
     return node;
   }
-
   node.marks = node.marks || [];
   node.marks.push(mark);
   return node;

package/dist/es2019/builders/utils/is-duplicate-mark.js

@@ -2,7 +2,6 @@ export function isDuplicateMark(node, type) {
   if (node.marks && node.marks.some(mark => mark.type === type)) {
     return true;
   }
-
   return false;
 }
 export function duplicateMarkError(node, type) {

package/dist/es2019/builders.js

@@ -1,4 +1,5 @@
 // Marks Builders
+
 export { breakout } from './builders/marks/breakout';
 export { code } from './builders/marks/code';
 export { em } from './builders/marks/em';
@@ -14,7 +15,9 @@ export { underline as u } from './builders/marks/underline';
 export { alignment } from './builders/marks/alignment';
 export { indentation } from './builders/marks/indentation';
 export { dataConsumer } from './builders/marks/data-consumer';
-export { fragment } from './builders/marks/fragment'; // Nodes Builders
+export { fragment } from './builders/marks/fragment';
+
+// Nodes Builders
 
 export { blockQuote } from './builders/nodes/blockquote';
 export { bodiedExtension } from './builders/nodes/bodied-extension';

package/dist/es2019/scrub/default-node-replacements.js

@@ -1,10 +1,8 @@
 import { scrubAttrs } from './scrub-content';
-
 const card = (node, {
   valueReplacements
 }) => {
   var _node$attrs;
-
   return {
     type: node.type,
     attrs: {
@@ -12,17 +10,14 @@ const card = (node, {
     }
   };
 };
-
 const mediaParent = node => {
   var _node$content;
-
   return {
     type: node.type,
     attrs: node.attrs ? scrubAttrs(node.type, node.attrs) : undefined,
     content: (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.filter(c => (c === null || c === void 0 ? void 0 : c.type) === 'media')
   };
 };
-
 export const defaultNodeReplacements = {
   emoji: () => ({
     type: 'emoji',
@@ -54,7 +49,6 @@ export const defaultNodeReplacements = {
     parent
   }) => {
     var _parent$node, _node$attrs$width, _node$attrs2, _node$attrs$height, _node$attrs3;
-
     const defaults = ((_parent$node = parent.node) === null || _parent$node === void 0 ? void 0 : _parent$node.type) === 'mediaSingle' ? {
       width: 600,
       height: 400
@@ -66,7 +60,8 @@ export const defaultNodeReplacements = {
     const height = (_node$attrs$height = (_node$attrs3 = node.attrs) === null || _node$attrs3 === void 0 ? void 0 : _node$attrs3.height) !== null && _node$attrs$height !== void 0 ? _node$attrs$height : defaults.height;
     return {
       type: 'media',
-      attrs: { ...scrubAttrs('media', node.attrs),
+      attrs: {
+        ...scrubAttrs('media', node.attrs),
         type: 'external',
         url: `https://dummyimage.com/${width}x${height}/f4f5f7/a5adba`
       }

package/dist/es2019/scrub/hash.js

@@ -2,10 +2,8 @@
 export const hash = input => {
   let result = 5381;
   let index = input.length;
-
   while (index > 0) {
     result = result * 33 ^ input.charCodeAt(--index);
   }
-
   return (result >>> 0).toString();
 };

package/dist/es2019/scrub/scrub-adf.js

@@ -3,50 +3,44 @@ import { scrubAttrs, scrubStr, scrubLink } from './scrub-content';
 import { defaultNodeReplacements } from './default-node-replacements';
 import { defaultValueReplacements } from './default-value-replacements';
 export default ((adf, options = {}) => {
-  const nodeReplacements = { ...defaultNodeReplacements,
+  const nodeReplacements = {
+    ...defaultNodeReplacements,
     ...options.nodeReplacements
   };
-  const valueReplacements = { ...defaultValueReplacements,
+  const valueReplacements = {
+    ...defaultValueReplacements,
     ...options.valueReplacements
   };
   return traverse(adf, {
     any: (node, parent) => {
       const replacement = nodeReplacements[node.type];
-
       if (typeof replacement === 'function') {
         const result = replacement(node, {
           parent,
           valueReplacements
         });
-
         if (result !== false) {
           return result;
         }
       }
-
       const updatedNode = {};
       Object.entries(node).forEach(([key, value]) => {
         if (['version', 'type', 'content', 'marks'].includes(key)) {
           updatedNode[key] = value;
         }
       });
-
       if (node.text && node.marks) {
         var _node$marks;
-
         updatedNode.marks = scrubLink((_node$marks = node.marks) !== null && _node$marks !== void 0 ? _node$marks : [], {
           valueReplacements
         });
       }
-
       if (node.text) {
         updatedNode.text = scrubStr(node.text);
       }
-
       if (node.attrs) {
         updatedNode.attrs = scrubAttrs(node.type, node.attrs);
       }
-
       return updatedNode;
     }
   });

package/dist/es2019/scrub/scrub-content.js

@@ -20,14 +20,12 @@ const BYPASS_ATTR_LIST = {
   tableRow: ['defaultMarks'],
   taskItem: ['state']
 };
-
 const fromEntries = iterable => {
   return [...iterable].reduce((obj, [key, val]) => {
     obj[key] = val;
     return obj;
   }, {});
 };
-
 const scrubNum = (val, start = 0) => {
   return parseInt(val.toString().split('').map((_, index) => {
     const base = start + index;
@@ -35,18 +33,17 @@ const scrubNum = (val, start = 0) => {
     return DUMMY_DIGITS[base % len];
   }).join(''), 10);
 };
-
 export const scrubStr = (val, offset = 0) => {
-  const base = DUMMY_TEXT.repeat(Math.ceil((offset + val.length) / DUMMY_TEXT.length)); // using [...val] splits emoji character pairs correctly, compared to
-  // something like "".split('')
+  const base = DUMMY_TEXT.repeat(Math.ceil((offset + val.length) / DUMMY_TEXT.length));
 
+  // using [...val] splits emoji character pairs correctly, compared to
+  // something like "".split('')
   return [...val].map((char, index, chars) => {
     if (/^\p{Nd}$/u.test(char)) {
       // Decimal digits
       return scrubNum(parseInt(char, 10), index).toString();
     } else if (/^\p{So}$/u.test(char)) {
       var _chars;
-
       // Emoji
       return ((_chars = chars[index - 1]) === null || _chars === void 0 ? void 0 : _chars.codePointAt(0)) === 8205 ? '' : '⭐️';
     } else if (/^\p{Sc}$/u.test(char)) {
@@ -74,59 +71,49 @@ export const scrubLink = (marks, {
 }) => {
   return marks.map(mark => {
     if (mark.type === 'link' && mark.attrs.href) {
-      return { ...mark,
-        attrs: { ...mark.attrs,
+      return {
+        ...mark,
+        attrs: {
+          ...mark.attrs,
           href: valueReplacements.href(mark.attrs.href)
         }
       };
     }
-
     return mark;
   });
 };
-
 const scrubObj = (nodeType, attrsObj) => {
   const entries = Object.entries(attrsObj).map(([key, value]) => {
     var _BYPASS_ATTR_LIST$nod;
-
     return (_BYPASS_ATTR_LIST$nod = BYPASS_ATTR_LIST[nodeType]) !== null && _BYPASS_ATTR_LIST$nod !== void 0 && _BYPASS_ATTR_LIST$nod.includes(key) ? [key, value] : [key, scrubAttrs(nodeType, value)];
   });
   return fromEntries(entries);
 };
-
 export const scrubAttrs = (nodeType, attrs, offset = 0) => {
   if (typeof attrs === 'number') {
     return scrubNum(attrs, offset);
   }
-
   if (typeof attrs === 'string') {
     return scrubStr(attrs, offset);
   }
-
   if (typeof attrs === 'boolean') {
     return attrs;
   }
-
   if (!attrs) {
     return attrs;
   }
-
   const attrsObj = attrs;
-
   if (attrsObj && attrsObj.constructor === Object && Object.keys(attrsObj).length === 0) {
     return {};
   }
-
   if (typeof attrsObj === 'object' && !Array.isArray(attrsObj)) {
     return scrubObj(nodeType, attrsObj);
   }
-
   if (Array.isArray(attrsObj)) {
     return attrsObj.map(el => {
       return typeof el === 'object' ? scrubObj(nodeType, el) : scrubAttrs(nodeType, el);
     });
   }
-
   throw new TypeError(`scrubAttrs: encountered unsupported attributes type "${typeof attrsObj}"
     of value ${JSON.stringify(attrsObj)}`);
 };

package/dist/es2019/transforms/dedupe-marks-transform.js

@@ -4,24 +4,20 @@ import { traverse } from '../traverse/traverse';
 // not include annotations here, because we do allow duplicate
 // annotations as long as they have unique id attributes (valid scenario)
 const markDuplicatesDisallowed = new Set(['strong', 'underline', 'textColor', 'link', 'em', 'subsup', 'strike']);
-
 const maybeHasDisallowedDuplicateMarks = node => {
   var _node$marks, _node$marks$map;
-
-  const markTypes = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : (_node$marks$map = _node$marks.map(mark => mark.type)) === null || _node$marks$map === void 0 ? void 0 : _node$marks$map.filter(markType => // For annotations, we are performing the same cheap check
+  const markTypes = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : (_node$marks$map = _node$marks.map(mark => mark.type)) === null || _node$marks$map === void 0 ? void 0 : _node$marks$map.filter(markType =>
+  // For annotations, we are performing the same cheap check
   // for duplicates by type, without considering IDs, to quickly determine
   // whether there may be potential deduping targets.
   // In the actual deduping logic in maybeRemoveDisallowedDuplicateMarks,
   // we correctly/safely dedupe annotations by their unique IDs.
   markDuplicatesDisallowed.has(markType) || markType === 'annotation');
-
   if (!(markTypes !== null && markTypes !== void 0 && markTypes.length)) {
     return false;
   }
-
   return new Set(markTypes).size !== markTypes.length;
 };
-
 const maybeRemoveDisallowedDuplicateMarks = node => {
   const quota = new Map();
   const annotationsQuota = new Map();
@@ -29,21 +25,16 @@ const maybeRemoveDisallowedDuplicateMarks = node => {
   markDuplicatesDisallowed.forEach(mark => {
     quota.set(mark, false);
   });
-
   if (!node.marks) {
     return {
       discardedMarks
     };
   }
-
   let dedupedMarks = node.marks.filter(mark => {
     const markType = mark.type;
-
     if (markType === 'annotation') {
       var _mark$attrs;
-
       const id = (_mark$attrs = mark.attrs) === null || _mark$attrs === void 0 ? void 0 : _mark$attrs.id;
-
       if (annotationsQuota.has(id)) {
         discardedMarks.push(mark);
         return false;
@@ -52,7 +43,6 @@ const maybeRemoveDisallowedDuplicateMarks = node => {
         return true;
       }
     }
-
     if (quota.has(markType)) {
       if (!quota.get(markType)) {
         quota.set(markType, true);
@@ -62,17 +52,16 @@ const maybeRemoveDisallowedDuplicateMarks = node => {
         return false;
       }
     }
-
     return true;
   });
   return {
-    node: { ...node,
+    node: {
+      ...node,
       marks: dedupedMarks
     },
     discardedMarks
   };
 };
-
 export const transformDedupeMarks = adf => {
   let isTransformed = false;
   let discardedMarks = [];
@@ -80,9 +69,9 @@ export const transformDedupeMarks = adf => {
     text: node => {
       if (maybeHasDisallowedDuplicateMarks(node)) {
         const result = maybeRemoveDisallowedDuplicateMarks(node);
-        discardedMarks = result.discardedMarks;
-
-        if (discardedMarks.length) {
+        const resultDiscardedMarks = result.discardedMarks;
+        if (resultDiscardedMarks.length) {
+          discardedMarks.push(...resultDiscardedMarks);
           isTransformed = true;
           return result.node;
         }

package/dist/es2019/transforms/helpers.js

@@ -1,5 +1,4 @@
 export const isEmpty = node => {
   var _node$content;
-
   return !(node !== null && node !== void 0 && (_node$content = node.content) !== null && _node$content !== void 0 && _node$content.length);
 };

package/dist/es2019/transforms/indentation-marks-transform.js

@@ -1,33 +1,27 @@
 import { traverse } from '../traverse/traverse';
-
 const hasChildHeadingWithIndentation = node => {
   var _node$content$some, _node$content;
-
   return (_node$content$some = (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.some(childNode => {
     var _childNode$marks;
-
     return (childNode === null || childNode === void 0 ? void 0 : childNode.type) === 'heading' && (childNode === null || childNode === void 0 ? void 0 : (_childNode$marks = childNode.marks) === null || _childNode$marks === void 0 ? void 0 : _childNode$marks.some(mark => mark.type === 'indentation'));
   })) !== null && _node$content$some !== void 0 ? _node$content$some : false;
 };
-
 const removeIndentationFromHeadings = node => {
   var _node$content2;
-
-  return { ...node,
+  return {
+    ...node,
     content: (_node$content2 = node.content) === null || _node$content2 === void 0 ? void 0 : _node$content2.map(childNode => {
       if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) === 'heading') {
         var _childNode$marks2;
-
-        return { ...childNode,
+        return {
+          ...childNode,
           marks: (_childNode$marks2 = childNode.marks) === null || _childNode$marks2 === void 0 ? void 0 : _childNode$marks2.filter(mark => mark.type !== 'indentation')
         };
       }
-
       return childNode;
     })
   };
 };
-
 export const transformIndentationMarks = adf => {
   let isTransformed = false;
   const transformedAdf = traverse(adf, {
@@ -36,6 +30,12 @@ export const transformIndentationMarks = adf => {
         isTransformed = true;
         return removeIndentationFromHeadings(node);
       }
+    },
+    tableHeader: node => {
+      if (hasChildHeadingWithIndentation(node)) {
+        isTransformed = true;
+        return removeIndentationFromHeadings(node);
+      }
     }
   });
   return {

package/dist/es2019/transforms/invalid-media-content-transform.js

@@ -1,69 +1,59 @@
 import { traverse } from '../traverse/traverse';
 import { isEmpty } from './helpers';
-
 const getChildrenTypeCounts = (nodeContent, allowedTypes) => {
   let childrenTypes = {};
   nodeContent.forEach((childNode, index) => {
     if (!(childNode !== null && childNode !== void 0 && childNode.type) || !allowedTypes.includes(childNode.type)) {
       return;
     }
-
     if (!childrenTypes[childNode.type]) {
       childrenTypes[childNode.type] = 1;
       return;
     }
-
     childrenTypes[childNode.type]++;
   });
   return childrenTypes;
 };
-
 const removeDuplicatedNodes = (type, content, predicate) => {
   let maxIterations = 10;
   let childrenTypeCounts = getChildrenTypeCounts(content, [type])[type];
   let firstPredicateNodeIndex = content.findIndex(predicate);
-
   while (childrenTypeCounts > 1 && firstPredicateNodeIndex > -1 && maxIterations-- > 0) {
     content.splice(firstPredicateNodeIndex, 1);
     firstPredicateNodeIndex = content.findIndex(predicate);
     childrenTypeCounts = getChildrenTypeCounts(content, [type])[type];
   }
 };
+
 /**
  * @param  {{[type:string]:number}} allowedTypes - array types allowed to deduplicate
  */
-
-
 const deduplicateMediaSingleChildren = (node, allowedTypes) => {
   if (!node.content) {
     return;
   }
-
   const content = [...node.content];
   Object.keys(allowedTypes).forEach(type => {
     //prioritise removing empty nodes first
-    removeDuplicatedNodes(type, content, node => (node === null || node === void 0 ? void 0 : node.type) === type && isEmpty(node)); //remove other remaining dupicates
-
+    removeDuplicatedNodes(type, content, node => (node === null || node === void 0 ? void 0 : node.type) === type && isEmpty(node));
+    //remove other remaining dupicates
     removeDuplicatedNodes(type, content, node => (node === null || node === void 0 ? void 0 : node.type) === type);
   });
-  return { ...node,
+  return {
+    ...node,
     content
   };
 };
-
 export const transformInvalidMediaContent = adf => {
   let isTransformed = false;
   const transformedAdf = traverse(adf, {
     mediaSingle: node => {
       var _node$content;
-
       if (!(node !== null && node !== void 0 && (_node$content = node.content) !== null && _node$content !== void 0 && _node$content.length)) {
         return;
       }
-
       const disallowedDuplicateTypes = ['media', 'caption'];
       const childrenTypes = getChildrenTypeCounts(node.content, disallowedDuplicateTypes);
-
       if (Object.values(childrenTypes).some(occurences => occurences > 1)) {
         isTransformed = true;
         return deduplicateMediaSingleChildren(node, childrenTypes);

package/dist/es2019/transforms/media-link-transform.js

@@ -6,38 +6,31 @@ export const transformMediaLinkMarks = adf => {
   const transformedAdf = traverse(adf, {
     mediaSingle: node => {
       var _node$content$;
-
       if (!node.marks || !node.content || ((_node$content$ = node.content[0]) === null || _node$content$ === void 0 ? void 0 : _node$content$.type) !== 'media') {
         return node;
       }
-
       let linkMark = null;
       node.marks.forEach((mark, i) => {
         if (mark.type === 'link') {
           var _node$marks;
-
           linkMark = mark;
           (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.splice(i, 1);
           isTransformed = true;
         }
       });
-
       if (node.marks.length === 0) {
         delete node.marks;
       }
-
       if (linkMark) {
         var _mediaNode$marks;
-
-        const mediaNode = node.content[0]; // only add link mark if media node doesnt already have one
-
+        const mediaNode = node.content[0];
+        // only add link mark if media node doesnt already have one
         if ((_mediaNode$marks = mediaNode.marks) !== null && _mediaNode$marks !== void 0 && _mediaNode$marks.every(mark => mark.type !== 'link')) {
           mediaNode.marks.push(linkMark);
         } else if (!mediaNode.marks) {
           mediaNode.marks = [linkMark];
         }
       }
-
       return node;
     }
   });