@atlaskit/adf-schema 19.2.0

package/dist/esm/schema/nodes/blockquote.js

@@ -0,0 +1,15 @@
+/**
+ * @name blockquote_node
+ */
+export var blockquote = {
+  content: '(paragraph | unsupportedBlock)+',
+  group: 'block',
+  defining: true,
+  selectable: false,
+  parseDOM: [{
+    tag: 'blockquote'
+  }],
+  toDOM: function toDOM() {
+    return ['blockquote', 0];
+  }
+};

package/dist/esm/schema/nodes/bodied-extension.js

@@ -0,0 +1,58 @@
+import { getExtensionAttrs } from '../../utils/extensions';
+
+var createBodiedExtensionNodeSpec = function createBodiedExtensionNodeSpec() {
+  var nodeSpec = {
+    inline: false,
+    group: 'block',
+    marks: 'link dataConsumer',
+    content: '(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaGroup | mediaSingle | decisionList | taskList | table | blockCard | extension | unsupportedBlock | embedCard)+',
+    defining: true,
+    selectable: true,
+    isolating: true,
+    attrs: {
+      extensionType: {
+        default: ''
+      },
+      extensionKey: {
+        default: ''
+      },
+      parameters: {
+        default: null
+      },
+      text: {
+        default: null
+      },
+      layout: {
+        default: 'default'
+      },
+      localId: {
+        default: null
+      }
+    },
+    parseDOM: [{
+      context: 'bodiedExtension//',
+      tag: '[data-node-type="bodied-extension"]',
+      skip: true
+    }, {
+      tag: '[data-node-type="bodied-extension"]',
+      getAttrs: function getAttrs(domNode) {
+        return getExtensionAttrs(domNode);
+      }
+    }],
+    toDOM: function toDOM(node) {
+      var attrs = {
+        'data-node-type': 'bodied-extension',
+        'data-extension-type': node.attrs.extensionType,
+        'data-extension-key': node.attrs.extensionKey,
+        'data-text': node.attrs.text,
+        'data-parameters': JSON.stringify(node.attrs.parameters),
+        'data-layout': node.attrs.layout,
+        'data-local-id:': node.attrs.localId
+      };
+      return ['div', attrs, 0];
+    }
+  };
+  return nodeSpec;
+};
+
+export var bodiedExtension = createBodiedExtensionNodeSpec();

package/dist/esm/schema/nodes/bullet-list.js

@@ -0,0 +1,21 @@
+// eslint-disable-next-line import/no-cycle
+
+/**
+ * @name bulletList_node
+ */
+export var bulletListSelector = '.ak-ul';
+export var bulletList = {
+  group: 'block',
+  content: 'listItem+',
+  selectable: false,
+  parseDOM: [{
+    tag: 'ul'
+  }],
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  toDOM: function toDOM() {
+    var attrs = {
+      class: bulletListSelector.substr(1)
+    };
+    return ['ul', attrs, 0];
+  }
+};

package/dist/esm/schema/nodes/caption.js

@@ -0,0 +1,19 @@
+/**
+ * @stage 0
+ * @name caption_node
+ */
+export var caption = {
+  content: '(text|hardBreak|mention|emoji|date|placeholder|inlineCard|status)*',
+  isolating: true,
+  marks: '_',
+  selectable: false,
+  parseDOM: [{
+    tag: 'figcaption[data-caption]'
+  }],
+  toDOM: function toDOM(node) {
+    var attrs = {
+      'data-caption': 'true'
+    };
+    return ['figcaption', attrs, 0];
+  }
+};

package/dist/esm/schema/nodes/code-block.js

@@ -0,0 +1,149 @@
+import { Fragment } from 'prosemirror-model';
+
+var getLanguageFromEditorStyle = function getLanguageFromEditorStyle(dom) {
+  return dom.getAttribute('data-language') || undefined;
+}; // example of BB style:
+// <div class="codehilite language-javascript"><pre><span>hello world</span><span>\n</span></pre></div>
+
+
+var getLanguageFromBitbucketStyle = function getLanguageFromBitbucketStyle(dom) {
+  if (dom && dom.classList.contains('codehilite')) {
+    // code block html from Bitbucket always contains an extra new line
+    return extractLanguageFromClass(dom.className);
+  }
+
+  return;
+}; // If there is a child code element, check that for data-language
+
+
+var getLanguageFromCode = function getLanguageFromCode(dom) {
+  var firstChild = dom.firstElementChild;
+
+  if (firstChild && firstChild.nodeName === 'CODE') {
+    return firstChild.getAttribute('data-language') || undefined;
+  }
+};
+
+var extractLanguageFromClass = function extractLanguageFromClass(className) {
+  var languageRegex = /(?:^|\s)language-([^\s]+)/;
+  var result = languageRegex.exec(className);
+
+  if (result && result[1]) {
+    return result[1];
+  }
+
+  return;
+};
+
+var removeLastNewLine = function removeLastNewLine(dom) {
+  var parent = dom && dom.parentElement;
+
+  if (parent && parent.classList.contains('codehilite')) {
+    dom.textContent = dom.textContent.replace(/\n$/, '');
+  }
+
+  return dom;
+};
+
+export var codeBlock = {
+  attrs: {
+    language: {
+      default: null
+    },
+    uniqueId: {
+      default: null
+    }
+  },
+  content: '(text | unsupportedInline)*',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  group: 'block',
+  code: true,
+  defining: true,
+  parseDOM: [{
+    tag: 'pre',
+    preserveWhitespace: 'full',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+      var language = getLanguageFromBitbucketStyle(dom.parentElement) || getLanguageFromEditorStyle(dom.parentElement) || getLanguageFromCode(dom) || dom.getAttribute('data-language');
+      dom = removeLastNewLine(dom);
+      return {
+        language: language
+      };
+    }
+  }, // Handle VSCode paste
+  // Checking `white-space: pre-wrap` is too aggressive @see ED-2627
+  {
+    tag: 'div[style]',
+    preserveWhitespace: 'full',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+
+      if (dom.style.whiteSpace === 'pre' || dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf('monospace') > -1) {
+        return {};
+      }
+
+      return false;
+    },
+    // @see ED-5682
+    getContent: function getContent(domNode, schema) {
+      var dom = domNode;
+      var code = Array.from(dom.children).map(function (child) {
+        return child.textContent;
+      }).filter(function (x) {
+        return x !== undefined;
+      }).join('\n');
+      return code ? Fragment.from(schema.text(code)) : Fragment.empty;
+    }
+  }, // Handle GitHub/Gist paste
+  {
+    tag: 'table[style]',
+    preserveWhitespace: 'full',
+    getAttrs: function getAttrs(dom) {
+      if (dom.querySelector('td[class*="blob-code"]')) {
+        return {};
+      }
+
+      return false;
+    }
+  }, {
+    tag: 'div.code-block',
+    preserveWhitespace: 'full',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode; // TODO: ED-5604 Fix it inside `react-syntax-highlighter`
+      // Remove line numbers
+
+      var lineNumber = dom.querySelectorAll('.react-syntax-highlighter-line-number');
+
+      if (lineNumber.length > 0) {
+        // It's possible to copy without the line numbers too hence this
+        // `react-syntax-highlighter-line-number` check, so that we don't remove real code
+        lineNumber.forEach(function (line) {
+          return line.remove();
+        });
+      }
+
+      return {};
+    }
+  }],
+  toDOM: function toDOM(node) {
+    return ['pre', ['code', {
+      'data-language': node.attrs.language
+    }, 0]];
+  }
+};
+export var toJSON = function toJSON(node) {
+  return {
+    attrs: Object.keys(node.attrs).reduce(function (memo, key) {
+      if (key === 'uniqueId') {
+        return memo;
+      }
+
+      if (key === 'language' && node.attrs.language === null) {
+        return memo;
+      }
+
+      memo[key] = node.attrs[key];
+      return memo;
+    }, {})
+  };
+};

package/dist/esm/schema/nodes/confluence-jira-issue.js

@@ -0,0 +1,47 @@
+var name = 'confluenceJiraIssue';
+export var confluenceJiraIssue = {
+  group: 'inline',
+  inline: true,
+  atom: true,
+  attrs: {
+    issueKey: {
+      default: ''
+    },
+    macroId: {
+      default: null
+    },
+    schemaVersion: {
+      default: null
+    },
+    server: {
+      default: null
+    },
+    serverId: {
+      default: null
+    }
+  },
+  parseDOM: [{
+    tag: "span[data-node-type=\"".concat(name, "\"]"),
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+      return {
+        issueKey: dom.textContent,
+        macroId: dom.dataset && dom.dataset.macroId,
+        schemaVersion: dom.dataset && dom.dataset.schemaVersion,
+        server: dom.dataset && dom.dataset.server,
+        serverId: dom.dataset && dom.dataset.serverId
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var attrs = {
+      'data-node-type': name,
+      'data-macro-id': node.attrs.macroId,
+      'data-schema-version': node.attrs.schemaVersion,
+      'data-server': node.attrs.server,
+      'data-server-id': node.attrs.serverId,
+      'data-jira-issue': node.attrs.issueKey
+    };
+    return ['span', attrs, node.attrs.issueKey];
+  }
+};

package/dist/esm/schema/nodes/confluence-unsupported-block.js

@@ -0,0 +1,26 @@
+var name = 'confluenceUnsupportedBlock';
+export var confluenceUnsupportedBlock = {
+  group: 'block',
+  attrs: {
+    cxhtml: {
+      default: null
+    }
+  },
+  toDOM: function toDOM(node) {
+    // NOTE: This node cannot be "contenteditable: false". If it's the only node in a document, PM throws an error because there's nowhere to put the cursor.
+    var attrs = {
+      'data-node-type': name,
+      'data-confluence-unsupported': 'block',
+      'data-confluence-unsupported-block-cxhtml': node.attrs['cxhtml']
+    };
+    return ['div', attrs, 'Unsupported content'];
+  },
+  parseDOM: [{
+    tag: "div[data-node-type=\"".concat(name, "\"]"),
+    getAttrs: function getAttrs(dom) {
+      return {
+        cxhtml: dom.getAttribute('data-confluence-unsupported-block-cxhtml')
+      };
+    }
+  }]
+};

package/dist/esm/schema/nodes/confluence-unsupported-inline.js

@@ -0,0 +1,27 @@
+var name = 'confluenceUnsupportedInline';
+export var confluenceUnsupportedInline = {
+  group: 'inline',
+  inline: true,
+  atom: true,
+  attrs: {
+    cxhtml: {
+      default: null
+    }
+  },
+  toDOM: function toDOM(node) {
+    var attrs = {
+      'data-node-type': name,
+      'data-confluence-unsupported': 'inline',
+      'data-confluence-unsupported-inline-cxhtml': node.attrs['cxhtml']
+    };
+    return ['div', attrs, 'Unsupported content'];
+  },
+  parseDOM: [{
+    tag: "div[data-node-type=\"".concat(name, "\"]"),
+    getAttrs: function getAttrs(dom) {
+      return {
+        cxhtml: dom.getAttribute('data-confluence-unsupported-inline-cxhtml')
+      };
+    }
+  }]
+};

package/dist/esm/schema/nodes/date.js

@@ -0,0 +1,28 @@
+/**
+ * @name date_node
+ */
+export var date = {
+  inline: true,
+  group: 'inline',
+  selectable: true,
+  attrs: {
+    timestamp: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-node-type="date"]',
+    getAttrs: function getAttrs(dom) {
+      return {
+        timestamp: dom.getAttribute('data-timestamp')
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var attrs = {
+      'data-node-type': 'date',
+      'data-timestamp': node.attrs.timestamp
+    };
+    return ['span', attrs];
+  }
+};

package/dist/esm/schema/nodes/decision-item.js

@@ -0,0 +1,36 @@
+import { uuid } from '../../utils/uuid';
+export var decisionItem = {
+  content: 'inline*',
+  defining: true,
+  marks: '_',
+  attrs: {
+    localId: {
+      default: ''
+    },
+    state: {
+      default: 'DECIDED'
+    }
+  },
+  parseDOM: [{
+    tag: 'li[data-decision-local-id]',
+    // Default priority is 50. We normally don't change this but since this node type is
+    // also used by list-item we need to make sure that we run this parser first.
+    priority: 100,
+    getAttrs: function getAttrs(dom) {
+      return {
+        localId: uuid.generate(),
+        state: dom.getAttribute('data-decision-state')
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var _node$attrs = node.attrs,
+        localId = _node$attrs.localId,
+        state = _node$attrs.state;
+    var attrs = {
+      'data-decision-local-id': localId || 'local-decision',
+      'data-decision-state': state
+    };
+    return ['li', attrs, 0];
+  }
+};

package/dist/esm/schema/nodes/decision-list.js

@@ -0,0 +1,39 @@
+import { uuid } from '../../utils/uuid';
+/**
+ * @name decisionList_node
+ */
+
+var name = 'decisionList';
+export var decisionListSelector = "[data-node-type=\"".concat(name, "\"]");
+export var decisionList = {
+  group: 'block',
+  defining: true,
+  content: '(decisionItem|unsupportedBlock)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  selectable: false,
+  attrs: {
+    localId: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: "ol".concat(decisionListSelector),
+    // Default priority is 50. We normally don't change this but since this node type is
+    // also used by ordered-list we need to make sure that we run this parser first.
+    priority: 100,
+    getAttrs: function getAttrs() {
+      return {
+        localId: uuid.generate()
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var localId = node.attrs.localId;
+    var attrs = {
+      'data-node-type': name,
+      'data-decision-list-local-id': localId || 'local-decision-list',
+      style: 'list-style: none; padding-left: 0'
+    };
+    return ['ol', attrs, 0];
+  }
+};