@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,58 @@
+import { getExtensionAttrs } from '../../utils/extensions';
+
+const createBodiedExtensionNodeSpec = () => {
+  const 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: domNode => getExtensionAttrs(domNode)
+    }],
+
+    toDOM(node) {
+      const 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 const bodiedExtension = createBodiedExtensionNodeSpec();

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

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

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

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

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

@@ -0,0 +1,143 @@
+import { Fragment } from 'prosemirror-model';
+
+const 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>
+
+
+const 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
+
+
+const getLanguageFromCode = dom => {
+  const firstChild = dom.firstElementChild;
+
+  if (firstChild && firstChild.nodeName === 'CODE') {
+    return firstChild.getAttribute('data-language') || undefined;
+  }
+};
+
+const extractLanguageFromClass = className => {
+  const languageRegex = /(?:^|\s)language-([^\s]+)/;
+  const result = languageRegex.exec(className);
+
+  if (result && result[1]) {
+    return result[1];
+  }
+
+  return;
+};
+
+const removeLastNewLine = dom => {
+  const parent = dom && dom.parentElement;
+
+  if (parent && parent.classList.contains('codehilite')) {
+    dom.textContent = dom.textContent.replace(/\n$/, '');
+  }
+
+  return dom;
+};
+
+export const 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: domNode => {
+      let dom = domNode;
+      const language = getLanguageFromBitbucketStyle(dom.parentElement) || getLanguageFromEditorStyle(dom.parentElement) || getLanguageFromCode(dom) || dom.getAttribute('data-language');
+      dom = removeLastNewLine(dom);
+      return {
+        language
+      };
+    }
+  }, // Handle VSCode paste
+  // Checking `white-space: pre-wrap` is too aggressive @see ED-2627
+  {
+    tag: 'div[style]',
+    preserveWhitespace: 'full',
+    getAttrs: domNode => {
+      const dom = domNode;
+
+      if (dom.style.whiteSpace === 'pre' || dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf('monospace') > -1) {
+        return {};
+      }
+
+      return false;
+    },
+    // @see ED-5682
+    getContent: (domNode, schema) => {
+      const dom = domNode;
+      const code = Array.from(dom.children).map(child => child.textContent).filter(x => x !== undefined).join('\n');
+      return code ? Fragment.from(schema.text(code)) : Fragment.empty;
+    }
+  }, // Handle GitHub/Gist paste
+  {
+    tag: 'table[style]',
+    preserveWhitespace: 'full',
+    getAttrs: dom => {
+      if (dom.querySelector('td[class*="blob-code"]')) {
+        return {};
+      }
+
+      return false;
+    }
+  }, {
+    tag: 'div.code-block',
+    preserveWhitespace: 'full',
+    getAttrs: domNode => {
+      const dom = domNode; // TODO: ED-5604 Fix it inside `react-syntax-highlighter`
+      // Remove line numbers
+
+      const 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(line => line.remove());
+      }
+
+      return {};
+    }
+  }],
+
+  toDOM(node) {
+    return ['pre', ['code', {
+      'data-language': node.attrs.language
+    }, 0]];
+  }
+
+};
+export const toJSON = node => ({
+  attrs: Object.keys(node.attrs).reduce((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/es2019/schema/nodes/confluence-jira-issue.js

@@ -0,0 +1,49 @@
+const name = 'confluenceJiraIssue';
+export const 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="${name}"]`,
+    getAttrs: domNode => {
+      const 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(node) {
+    const 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/es2019/schema/nodes/confluence-unsupported-block.js

@@ -0,0 +1,30 @@
+const name = 'confluenceUnsupportedBlock';
+export const confluenceUnsupportedBlock = {
+  group: 'block',
+  attrs: {
+    cxhtml: {
+      default: null
+    }
+  },
+
+  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.
+    const 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="${name}"]`,
+
+    getAttrs(dom) {
+      return {
+        cxhtml: dom.getAttribute('data-confluence-unsupported-block-cxhtml')
+      };
+    }
+
+  }]
+};

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

@@ -0,0 +1,31 @@
+const name = 'confluenceUnsupportedInline';
+export const confluenceUnsupportedInline = {
+  group: 'inline',
+  inline: true,
+  atom: true,
+  attrs: {
+    cxhtml: {
+      default: null
+    }
+  },
+
+  toDOM(node) {
+    const 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="${name}"]`,
+
+    getAttrs(dom) {
+      return {
+        cxhtml: dom.getAttribute('data-confluence-unsupported-inline-cxhtml')
+      };
+    }
+
+  }]
+};

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

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

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

@@ -0,0 +1,37 @@
+import { uuid } from '../../utils/uuid';
+export const 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: dom => ({
+      localId: uuid.generate(),
+      state: dom.getAttribute('data-decision-state')
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      localId,
+      state
+    } = node.attrs;
+    const attrs = {
+      'data-decision-local-id': localId || 'local-decision',
+      'data-decision-state': state
+    };
+    return ['li', attrs, 0];
+  }
+
+};

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

@@ -0,0 +1,41 @@
+import { uuid } from '../../utils/uuid';
+/**
+ * @name decisionList_node
+ */
+
+const name = 'decisionList';
+export const decisionListSelector = `[data-node-type="${name}"]`;
+export const decisionList = {
+  group: 'block',
+  defining: true,
+  content: '(decisionItem|unsupportedBlock)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  selectable: false,
+  attrs: {
+    localId: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: `ol${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: () => ({
+      localId: uuid.generate()
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      localId
+    } = node.attrs;
+    const 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];
+  }
+
+};