@modusoperandi/licit 1.1.3 → 1.1.5

package/ParagraphNodeSpec.js.flow

@@ -74,6 +74,7 @@ const ParagraphNodeSpec: NodeSpec = {
   },
   content: 'inline*',
   group: 'block',
+  defining: true,
   parseDOM: [
     {
       tag: 'p',
@@ -84,15 +85,10 @@ const ParagraphNodeSpec: NodeSpec = {
 };
 
 function getAttrs(dom: HTMLElement): Object {
-  const {
-    lineHeight,
-    textAlign,
-    marginLeft,
-    paddingTop,
-    paddingBottom,
-  } = dom.style;
+  const { lineHeight, textAlign, marginLeft, paddingTop, paddingBottom } =
+    dom.style;
 
-  let align = dom.getAttribute('align') || textAlign || '';
+  let align = dom.getAttribute('align') || textAlign || 'left';
   align = ALIGN_PATTERN.test(align) ? align : null;
 
   let indent = parseInt(dom.getAttribute(ATTRIBUTE_INDENT), 10);
@@ -109,10 +105,12 @@ function getAttrs(dom: HTMLElement): Object {
   const overriddenAlign = dom.getAttribute('overriddenAlign') || '';
   const overriddenAlignValue = dom.getAttribute('overriddenAlignValue') || '';
   const overriddenLineSpacing = dom.getAttribute('overriddenLineSpacing') || '';
-  const overriddenLineSpacingValue = dom.getAttribute('overriddenLineSpacingValue') || '';
+  const overriddenLineSpacingValue =
+    dom.getAttribute('overriddenLineSpacingValue') || '';
   const overriddenIndent = dom.getAttribute('overriddenIndent') || '';
   const overriddenIndentValue = dom.getAttribute('overriddenIndentValue') || '';
   const innerLink = dom.getAttribute('innerLink') || '';
+  const objectId = dom.getAttribute('objectId') || '';
   return {
     align,
     indent,
@@ -127,6 +125,7 @@ function getAttrs(dom: HTMLElement): Object {
     overriddenIndent,
     overriddenIndentValue,
     innerLink,
+    objectId,
   };
 }
 
@@ -135,7 +134,7 @@ function getStyle(attrs: Object) {
     attrs.align,
     attrs.lineSpacing,
     attrs.paddingTop,
-    attrs.paddingBottom,
+    attrs.paddingBottom
   );
 }
 
@@ -161,12 +160,21 @@ function getStyleEx(align, lineSpacing, paddingTop, paddingBottom) {
     style += `padding-bottom: ${paddingBottom};`;
   }
   return { style };
-
 }
 
 function toDOM(node: Node): Array<any> {
-  const { indent, id, overriddenAlign,overriddenAlignValue, overriddenLineSpacing,overriddenLineSpacingValue, overriddenIndent,overriddenIndentValue, innerLink } = node.attrs;
-  const attrs = {};
+  const {
+    indent,
+    id,
+    overriddenAlign,
+    overriddenAlignValue,
+    overriddenLineSpacing,
+    overriddenLineSpacingValue,
+    overriddenIndent,
+    overriddenIndentValue,
+    innerLink,
+  } = node.attrs;
+  const attrs = { ...node.attrs };
   const { style } = getStyle(node.attrs);
 
   style && (attrs.style = style);
@@ -196,7 +204,10 @@ export const getParagraphStyle = getStyle;
 
 export function convertMarginLeftToIndentValue(marginLeft: string): number {
   const ptValue = convertToCSSPTValue(marginLeft);
-  return Math.min(Math.max(Math.floor(ptValue / INDENT_MARGIN_PT_SIZE), MIN_INDENT_LEVEL), MAX_INDENT_LEVEL);
+  return Math.min(
+    Math.max(Math.floor(ptValue / INDENT_MARGIN_PT_SIZE), MIN_INDENT_LEVEL),
+    MAX_INDENT_LEVEL
+  );
 }
 
 export default ParagraphNodeSpec;

package/StrikeMarkSpec.js

@@ -1,15 +1,22 @@
 // https://bitbucket.org/atlassian/atlaskit/src/34facee3f461/packages/editor-core/src/schema/nodes/?at=master
 var StrikeMarkSpec = {
+  attrs: {
+    overridden: {
+      "default": false
+    } // Optional attribute for additional logic
+  },
   parseDOM: [{
-    style: 'text-decoration',
-    getAttrs: function getAttrs(value) {
-      return value === 'line-through' && null;
+    tag: 'strike',
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
     }
   }],
-  toDOM: function toDOM() {
-    var style = 'text-decoration: line-through';
-    return ['span', {
-      style: style
+  toDOM: function toDOM(mark) {
+    return ['strike', {
+      overridden: mark.attrs.overridden
     }, 0];
   }
 };

package/StrikeMarkSpec.js.flow

@@ -4,17 +4,20 @@ import type { MarkSpec } from './Types.js';
 
 // https://bitbucket.org/atlassian/atlaskit/src/34facee3f461/packages/editor-core/src/schema/nodes/?at=master
 const StrikeMarkSpec: MarkSpec = {
+  attrs: {
+    overridden: { default: false }, // Optional attribute for additional logic
+  },
   parseDOM: [
     {
-      style: 'text-decoration',
-      getAttrs: (value) => {
-        return value === 'line-through' && null;
-      },
+      tag: 'strike',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
     },
   ],
-  toDOM() {
-    const style = 'text-decoration: line-through';
-    return ['span', { style }, 0];
+  toDOM(mark) {
+    return ['strike', { overridden: mark.attrs.overridden }, 0];
   },
 };
 

package/StrongMarkSpec.js

@@ -1,25 +1,38 @@
-var STRONG_DOM = ['strong', 0];
-var CSS_BOLD_PATTERN = /^(bold(er)?|[5-9]\d{2,})$/;
 var StrongMarkSpec = {
-  parseDOM: [{
-    tag: 'strong'
+  attrs: {
+    overridden: {
+      "default": false
+    }
   },
-  // This works around a Google Docs misbehavior where
-  // pasted content will be inexplicably wrapped in `<b>`
-  // tags with a font-weight normal.
-  {
+  parseDOM: [{
+    tag: 'strong',
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
+    }
+  }, {
     tag: 'b',
-    getAttrs: function getAttrs(node) {
-      return node.style.fontWeight != 'normal' && null;
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
     }
   }, {
-    style: 'font-weight',
-    getAttrs: function getAttrs(value) {
-      return CSS_BOLD_PATTERN.test(value) && null;
+    tag: 'span[style*=font-weight]',
+    getAttrs: function getAttrs(value, dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
     }
   }],
-  toDOM: function toDOM() {
-    return STRONG_DOM;
+  toDOM: function toDOM(mark) {
+    return ['strong', {
+      overridden: mark.attrs.overridden
+    }, 0];
   }
 };
 export default StrongMarkSpec;

package/StrongMarkSpec.js.flow

@@ -2,23 +2,37 @@
 
 import type { MarkSpec } from './Types.js';
 
-const STRONG_DOM = ['strong', 0];
-const CSS_BOLD_PATTERN = /^(bold(er)?|[5-9]\d{2,})$/;
-
 const StrongMarkSpec: MarkSpec = {
+  attrs: {
+    overridden: { default: false }
+  },
   parseDOM: [
-    { tag: 'strong' },
-    // This works around a Google Docs misbehavior where
-    // pasted content will be inexplicably wrapped in `<b>`
-    // tags with a font-weight normal.
-    { tag: 'b', getAttrs: (node) => node.style.fontWeight != 'normal' && null },
+
+    {
+      tag: 'strong',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
+    },
+    {
+      tag: 'b',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
+    },
     {
-      style: 'font-weight',
-      getAttrs: (value) => CSS_BOLD_PATTERN.test(value) && null,
+      tag: 'span[style*=font-weight]',
+      getAttrs: (value, dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+
+      },
     },
   ],
-  toDOM() {
-    return STRONG_DOM;
+  toDOM(mark) {
+    return ['strong', { overridden: mark.attrs.overridden }, 0];
   },
 };
 

package/TextColorMarkSpec.js

@@ -2,27 +2,37 @@ import { Node } from 'prosemirror-model';
 import toCSSColor from './ui/toCSSColor.js';
 var TextColorMarkSpec = {
   attrs: {
-    color: ''
+    color: {
+      "default": null
+    },
+    //  Allow missing color
+    overridden: {
+      "default": false
+    }
   },
   inline: true,
   group: 'inline',
   parseDOM: [{
-    style: 'color',
-    getAttrs: function getAttrs(color) {
+    tag: 'span[style*=color]',
+    getAttrs: function getAttrs(dom) {
+      var color = dom.style.color;
+      var overridden = dom.getAttribute('overridden') === 'true'; // Extract overridden flag
       return {
-        color: toCSSColor(color)
+        color: toCSSColor(color),
+        overridden: overridden
       };
     }
   }],
   toDOM: function toDOM(node) {
-    var color = node.attrs.color;
-    var style = '';
+    var _node$attrs = node.attrs,
+      color = _node$attrs.color,
+      overridden = _node$attrs.overridden;
+    var attrs = {};
     if (color) {
-      style += "color: ".concat(color, ";");
+      attrs.style = "color: ".concat(color, ";");
+      attrs['overridden'] = overridden.toString();
     }
-    return ['span', {
-      style: style
-    }, 0];
+    return ['span', attrs, 0];
   }
 };
 export default TextColorMarkSpec;

package/TextColorMarkSpec.js.flow

@@ -8,27 +8,32 @@ import type { MarkSpec } from './Types.js';
 
 const TextColorMarkSpec: MarkSpec = {
   attrs: {
-    color: '',
+    color: { default: null }, //  Allow missing color
+    overridden: { default: false },
   },
   inline: true,
   group: 'inline',
   parseDOM: [
     {
-      style: 'color',
-      getAttrs: (color) => {
+      tag: 'span[style*=color]',
+      getAttrs: (dom: HTMLElement) => {
+        const { color } = dom.style;
+        const overridden = dom.getAttribute('overridden') === 'true'; // Extract overridden flag
         return {
           color: toCSSColor(color),
+          overridden
         };
       },
     },
   ],
   toDOM(node: Node) {
-    const { color } = node.attrs;
-    let style = '';
+    const { color, overridden } = node.attrs;
+    const attrs = {};
     if (color) {
-      style += `color: ${color};`;
+      attrs.style = `color: ${color};`;
+      attrs['overridden'] = overridden.toString();
     }
-    return ['span', { style }, 0];
+    return ['span', attrs, 0];
   },
 };
 

package/TextHighlightMarkSpec.js

@@ -2,29 +2,42 @@ import { Node } from 'prosemirror-model';
 import { isTransparent, toCSSColor } from './ui/toCSSColor.js';
 var TextHighlightMarkSpec = {
   attrs: {
-    highlightColor: ''
+    highlightColor: {
+      "default": null
+    },
+    // Allow missing color
+    overridden: {
+      "default": false
+    }
   },
   inline: true,
   group: 'inline',
   parseDOM: [{
     tag: 'span[style*=background-color]',
+    priority: 100,
     getAttrs: function getAttrs(dom) {
       var backgroundColor = dom.style.backgroundColor;
       var color = toCSSColor(backgroundColor);
+      var overridden = dom.getAttribute('overridden') === 'true'; // Extract overridden flag
+
       return {
-        highlightColor: isTransparent(color) ? '' : color
+        highlightColor: isTransparent(color) ? '' : color,
+        overridden: overridden // Ensure overridden is captured
       };
     }
   }],
   toDOM: function toDOM(node) {
-    var highlightColor = node.attrs.highlightColor;
-    var style = '';
+    var _node$attrs = node.attrs,
+      highlightColor = _node$attrs.highlightColor,
+      overridden = _node$attrs.overridden;
+    var attrs = {};
     if (highlightColor) {
-      style += "background-color: ".concat(highlightColor, ";");
+      attrs.style = "background-color: ".concat(highlightColor, ";");
     }
-    return ['span', {
-      style: style
-    }, 0];
+
+    // Store overridden flag properly as a data attribute
+    attrs['overridden'] = overridden.toString();
+    return ['span', attrs, 0];
   }
 };
 export default TextHighlightMarkSpec;

package/TextHighlightMarkSpec.js.flow

@@ -1,37 +1,46 @@
 // @flow
 
 import { Node } from 'prosemirror-model';
-
 import { isTransparent, toCSSColor } from './ui/toCSSColor.js';
 
 import type { MarkSpec } from './Types.js';
 
 const TextHighlightMarkSpec: MarkSpec = {
   attrs: {
-    highlightColor: '',
+    highlightColor: { default: null }, // Allow missing color
+    overridden: { default: false },
   },
   inline: true,
   group: 'inline',
   parseDOM: [
     {
       tag: 'span[style*=background-color]',
+      priority: 100,
       getAttrs: (dom: HTMLElement) => {
-        const {backgroundColor} = dom.style;
+        const { backgroundColor } = dom.style;
         const color = toCSSColor(backgroundColor);
+        const overridden = dom.getAttribute('overridden') === 'true'; // Extract overridden flag
+
         return {
           highlightColor: isTransparent(color) ? '' : color,
+          overridden, // Ensure overridden is captured
         };
       },
     },
   ],
 
   toDOM(node: Node) {
-    const {highlightColor} = node.attrs;
-    let style = '';
+    const { highlightColor, overridden } = node.attrs;
+    const attrs = {};
+
     if (highlightColor) {
-      style += `background-color: ${highlightColor};`;
+      attrs.style = `background-color: ${highlightColor};`;
     }
-    return ['span', {style}, 0];
+
+    // Store overridden flag properly as a data attribute
+    attrs['overridden'] = overridden.toString();
+
+    return ['span', attrs, 0];
   },
 };
 

package/TextSubMarkSpec.js

@@ -1,14 +1,30 @@
 var TextSubMarkSpec = {
+  attrs: {
+    overridden: {
+      "default": false
+    }
+  },
   parseDOM: [{
-    tag: 'sub'
+    tag: 'sub',
+    priority: 150,
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
+    }
   }, {
     style: 'vertical-align',
     getAttrs: function getAttrs(value) {
-      return value === 'sub' && null;
+      return value === 'sub' ? {
+        overridden: true
+      } : null;
     }
   }],
-  toDOM: function toDOM() {
-    return ['sub', 0];
+  toDOM: function toDOM(mark) {
+    return ['sub', {
+      overridden: mark.attrs.overridden
+    }, 0];
   }
 };
 export default TextSubMarkSpec;

package/TextSubMarkSpec.js.flow

@@ -3,17 +3,25 @@
 import type { MarkSpec } from './Types.js';
 
 const TextSubMarkSpec: MarkSpec = {
+  attrs: {
+    overridden: { default: false },
+  },
   parseDOM: [
-    { tag: 'sub' },
+    {
+      tag: 'sub',
+      priority: 150,
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
+    },
     {
       style: 'vertical-align',
-      getAttrs: (value) => {
-        return value === 'sub' && null;
-      },
+      getAttrs: (value) => (value === 'sub' ? { overridden: true } : null),
     },
   ],
-  toDOM() {
-    return ['sub', 0];
+  toDOM(mark) {
+    return ['sub', { overridden: mark.attrs.overridden }, 0];
   },
 };
 

package/TextSuperMarkSpec.js

@@ -1,14 +1,29 @@
 var TextSuperMarkSpec = {
+  attrs: {
+    overridden: {
+      "default": false
+    }
+  },
   parseDOM: [{
-    tag: 'sup'
+    tag: 'sup',
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
+    }
   }, {
     style: 'vertical-align',
     getAttrs: function getAttrs(value) {
-      return value === 'super' && null;
+      return value === 'sup' ? {
+        overridden: true
+      } : null;
     }
   }],
-  toDOM: function toDOM() {
-    return ['sup', 0];
+  toDOM: function toDOM(mark) {
+    return ['sup', {
+      overridden: mark.attrs.overridden
+    }, 0];
   }
 };
 export default TextSuperMarkSpec;

package/TextSuperMarkSpec.js.flow

@@ -3,17 +3,25 @@
 import type { MarkSpec } from './Types.js';
 
 const TextSuperMarkSpec: MarkSpec = {
+  attrs: {
+    overridden: { default: false },
+  },
   parseDOM: [
-    { tag: 'sup' },
+    {
+      tag: 'sup',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
+    },
+
     {
       style: 'vertical-align',
-      getAttrs: (value) => {
-        return value === 'super' && null;
-      },
+      getAttrs: (value) => (value === 'sup' ? { overridden: true } : null),
     },
   ],
-  toDOM() {
-    return ['sup', 0];
+  toDOM(mark) {
+    return ['sup', { overridden: mark.attrs.overridden }, 0];
   },
 };
 

package/TextUnderlineMarkSpec.js

@@ -1,20 +1,23 @@
 // https://bitbucket.org/atlassian/atlaskit/src/34facee3f461/packages/editor-core/src/schema/nodes/?at=master
 var TextUnderlineMarkSpec = {
-  parseDOM: [{
-    tag: 'u'
-  }, {
-    style: 'text-decoration-line',
-    getAttrs: function getAttrs(value) {
-      return value === 'underline' && null;
+  attrs: {
+    overridden: {
+      "default": false
     }
-  }, {
-    style: 'text-decoration',
-    getAttrs: function getAttrs(value) {
-      return value === 'underline' && null;
+  },
+  parseDOM: [{
+    tag: 'u',
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
     }
   }],
-  toDOM: function toDOM() {
-    return ['u', 0];
+  toDOM: function toDOM(mark) {
+    return ['u', {
+      overridden: mark.attrs.overridden
+    }, 0];
   }
 };
 export default TextUnderlineMarkSpec;

package/TextUnderlineMarkSpec.js.flow

@@ -4,23 +4,20 @@ import type { MarkSpec } from './Types.js';
 
 // https://bitbucket.org/atlassian/atlaskit/src/34facee3f461/packages/editor-core/src/schema/nodes/?at=master
 const TextUnderlineMarkSpec: MarkSpec = {
+  attrs: {
+    overridden: { default: false },
+  },
   parseDOM: [
-    { tag: 'u' },
-    {
-      style: 'text-decoration-line',
-      getAttrs: (value) => {
-        return value === 'underline' && null;
-      },
-    },
     {
-      style: 'text-decoration',
-      getAttrs: (value) => {
-        return value === 'underline' && null;
-      },
+      tag: 'u',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
     },
   ],
-  toDOM() {
-    return ['u', 0];
+  toDOM(mark) {
+    return ['u', { overridden: mark.attrs.overridden }, 0];
   },
 };