@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJSON = exports.codeBlock = void 0;
+
+var _prosemirrorModel = require("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;
+};
+
+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 ? _prosemirrorModel.Fragment.from(schema.text(code)) : _prosemirrorModel.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]];
+  }
+};
+exports.codeBlock = codeBlock;
+
+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;
+    }, {})
+  };
+};
+
+exports.toJSON = toJSON;

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

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confluenceJiraIssue = void 0;
+var name = 'confluenceJiraIssue';
+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];
+  }
+};
+exports.confluenceJiraIssue = confluenceJiraIssue;

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confluenceUnsupportedBlock = void 0;
+var name = 'confluenceUnsupportedBlock';
+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')
+      };
+    }
+  }]
+};
+exports.confluenceUnsupportedBlock = confluenceUnsupportedBlock;

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

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confluenceUnsupportedInline = void 0;
+var name = 'confluenceUnsupportedInline';
+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')
+      };
+    }
+  }]
+};
+exports.confluenceUnsupportedInline = confluenceUnsupportedInline;

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.date = void 0;
+
+/**
+ * @name date_node
+ */
+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];
+  }
+};
+exports.date = date;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decisionItem = void 0;
+
+var _uuid = require("../../utils/uuid");
+
+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.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];
+  }
+};
+exports.decisionItem = decisionItem;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decisionList = exports.decisionListSelector = void 0;
+
+var _uuid = require("../../utils/uuid");
+
+var name = 'decisionList';
+var decisionListSelector = "[data-node-type=\"".concat(name, "\"]");
+exports.decisionListSelector = decisionListSelector;
+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.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];
+  }
+};
+exports.decisionList = decisionList;

package/dist/cjs/schema/nodes/doc.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.doc = void 0;
+
+/**
+ * @name doc_node
+ */
+var doc = {
+  content: '(block|layoutSection)+',
+  marks: 'alignment breakout dataConsumer indentation link unsupportedMark unsupportedNodeAttribute'
+};
+exports.doc = doc;

package/dist/cjs/schema/nodes/embed-card.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.embedCard = void 0;
+
+/**
+ * @name embedCard_node
+ */
+var embedCard = {
+  inline: false,
+  group: 'block',
+  selectable: true,
+  attrs: {
+    url: {
+      default: ''
+    },
+    layout: {
+      default: 'center'
+    },
+    width: {
+      default: 100
+    },
+    originalWidth: {
+      default: null
+    },
+    originalHeight: {
+      default: null
+    }
+  },
+  parseDOM: [{
+    tag: 'div[data-embed-card]',
+    getAttrs: function getAttrs(dom) {
+      return {
+        url: dom.getAttribute('data-card-url'),
+        layout: dom.getAttribute('data-layout') || 'center',
+        width: Number(dom.getAttribute('data-width')) || null,
+        originalWidth: Number(dom.getAttribute('data-card-original-width')) || null,
+        originalHeight: Number(dom.getAttribute('data-card-original-height')) || null
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var _node$attrs = node.attrs,
+        url = _node$attrs.url,
+        layout = _node$attrs.layout,
+        width = _node$attrs.width,
+        originalWidth = _node$attrs.originalWidth,
+        originalHeight = _node$attrs.originalHeight;
+    var attrs = {
+      'data-embed-card': '',
+      'data-card-url': url,
+      'data-layout': layout,
+      'data-width': width,
+      'data-original-width': originalWidth,
+      'data-original-height': originalHeight
+    };
+    return ['div', attrs];
+  }
+};
+exports.embedCard = embedCard;