@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,80 @@
+export var USER_TYPES;
+
+(function (USER_TYPES) {
+  USER_TYPES["DEFAULT"] = "DEFAULT";
+  USER_TYPES["SPECIAL"] = "SPECIAL";
+  USER_TYPES["APP"] = "APP";
+})(USER_TYPES || (USER_TYPES = {}));
+
+export var mention = {
+  inline: true,
+  group: 'inline',
+  selectable: true,
+  attrs: {
+    id: {
+      default: ''
+    },
+    text: {
+      default: ''
+    },
+    accessLevel: {
+      default: ''
+    },
+    userType: {
+      default: null
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-mention-id]',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+      var attrs = {
+        id: dom.getAttribute('data-mention-id') || mention.attrs.id.default,
+        text: dom.textContent || mention.attrs.text.default,
+        accessLevel: dom.getAttribute('data-access-level') || mention.attrs.accessLevel.default
+      };
+      var userType = dom.getAttribute('data-user-type');
+
+      if (USER_TYPES[userType]) {
+        attrs.userType = userType;
+      }
+
+      return attrs;
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var _node$attrs = node.attrs,
+        id = _node$attrs.id,
+        accessLevel = _node$attrs.accessLevel,
+        text = _node$attrs.text,
+        userType = _node$attrs.userType;
+    var attrs = {
+      'data-mention-id': id,
+      'data-access-level': accessLevel,
+      contenteditable: 'false'
+    };
+
+    if (userType) {
+      attrs['data-user-type'] = userType;
+    }
+
+    return ['span', attrs, text];
+  }
+};
+
+var isOptional = function isOptional(key) {
+  return ['userType'].indexOf(key) > -1;
+};
+
+export var toJSON = function toJSON(node) {
+  return {
+    attrs: Object.keys(node.attrs).reduce(function (obj, key) {
+      if (isOptional(key) && !node.attrs[key]) {
+        return obj;
+      }
+
+      obj[key] = node.attrs[key];
+      return obj;
+    }, {})
+  };
+};

package/dist/esm/schema/nodes/nested-expand.js

@@ -0,0 +1,56 @@
+/**
+ * @name nestedExpand_content
+ * @minItems 1
+ * @allowUnsupportedBlock true
+ */
+
+/**
+ * @name nestedExpand_node
+ */
+
+/**
+ * @name nestedExpand_with_no_marks_node
+ */
+export var nestedExpand = {
+  inline: false,
+  marks: 'link unsupportedMark unsupportedNodeAttribute',
+  content: '(paragraph | heading | mediaSingle | mediaGroup | unsupportedBlock)+',
+  isolating: true,
+  selectable: true,
+  attrs: {
+    title: {
+      default: ''
+    },
+    __expanded: {
+      default: true
+    }
+  },
+  parseDOM: [{
+    context: 'nestedExpand//',
+    tag: '[data-node-type="nestedExpand"]',
+    skip: true
+  }, {
+    tag: '[data-node-type="nestedExpand"] button',
+    ignore: true
+  }, {
+    tag: '[data-node-type="expand"] button',
+    ignore: true
+  }, {
+    tag: 'div[data-node-type="nestedExpand"]',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+      return {
+        title: dom.getAttribute('data-title'),
+        __expanded: true
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var attrs = {
+      'data-node-type': 'nestedExpand',
+      'data-title': node.attrs.title,
+      'data-expanded': node.attrs.__expanded
+    };
+    return ['div', attrs, 0];
+  }
+};

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

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

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

@@ -0,0 +1,76 @@
+export var PanelType;
+
+(function (PanelType) {
+  PanelType["INFO"] = "info";
+  PanelType["NOTE"] = "note";
+  PanelType["TIP"] = "tip";
+  PanelType["WARNING"] = "warning";
+  PanelType["ERROR"] = "error";
+  PanelType["SUCCESS"] = "success";
+  PanelType["CUSTOM"] = "custom";
+})(PanelType || (PanelType = {}));
+
+//TODO: ED-10445 rename to panel and merge with the other panel node spec, after emoji panels moved to full schema
+export var customPanel = {
+  group: 'block',
+  content: '(paragraph | heading | bulletList | orderedList | blockCard | unsupportedBlock)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  attrs: {
+    panelType: {
+      default: 'info'
+    },
+    panelIcon: {
+      default: null
+    },
+    panelColor: {
+      default: null
+    }
+  },
+  parseDOM: [{
+    tag: 'div[data-panel-type]',
+    getAttrs: function getAttrs(dom) {
+      return {
+        panelType: dom.getAttribute('data-panel-type'),
+        panelIcon: dom.getAttribute('data-panel-icon'),
+        panelColor: dom.getAttribute('data-panel-color')
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var _node$attrs = node.attrs,
+        panelType = _node$attrs.panelType,
+        panelIcon = _node$attrs.panelIcon,
+        panelColor = _node$attrs.panelColor;
+    var attrs = {
+      'data-panel-type': panelType,
+      'data-panel-icon': panelIcon,
+      'data-panel-color': panelColor
+    };
+    return ['div', attrs, ['div', {}, 0]];
+  }
+};
+export var panel = {
+  group: 'block',
+  content: '(paragraph | heading | bulletList | orderedList | blockCard | unsupportedBlock)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  attrs: {
+    panelType: {
+      default: 'info'
+    }
+  },
+  parseDOM: [{
+    tag: 'div[data-panel-type]',
+    getAttrs: function getAttrs(dom) {
+      return {
+        panelType: dom.getAttribute('data-panel-type')
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var panelType = node.attrs.panelType;
+    var attrs = {
+      'data-panel-type': panelType
+    };
+    return ['div', attrs, ['div', {}, 0]];
+  }
+};

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

@@ -0,0 +1,37 @@
+/**
+ * @name paragraph_node
+ */
+
+/**
+ * @name paragraph_with_no_marks_node
+ */
+
+/**
+ * NOTE: Need this because TS is too smart and inline everything.
+ * So we need to give them separate identity.
+ * Probably there's a way to solve it but that will need time and exploration.
+ * // http://bit.ly/2raXFX5
+ * type T1 = X | Y
+ * type T2 = A | T1 | B // T2 = A | X | Y | B
+ */
+
+/**
+ * @name paragraph_with_alignment_node
+ */
+
+/**
+ * @name paragraph_with_indentation_node
+ */
+var pDOM = ['p', 0];
+export var paragraph = {
+  selectable: false,
+  content: 'inline*',
+  group: 'block',
+  marks: 'strong code em link strike subsup textColor typeAheadQuery underline confluenceInlineComment action annotation unsupportedMark unsupportedNodeAttribute dataConsumer',
+  parseDOM: [{
+    tag: 'p'
+  }],
+  toDOM: function toDOM() {
+    return pDOM;
+  }
+};

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

@@ -0,0 +1,31 @@
+/**
+ * @name placeholder_node
+ */
+export var placeholder = {
+  inline: true,
+  group: 'inline',
+  selectable: false,
+  marks: '',
+  attrs: {
+    text: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-placeholder]',
+    getAttrs: function getAttrs(dom) {
+      return {
+        text: dom.getAttribute('data-placeholder') || placeholder.attrs.text.default
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var text = node.attrs.text;
+    var attrs = {
+      'data-placeholder': text,
+      // Needs to be edtiable for mobile to not close keyboard
+      contenteditable: 'true'
+    };
+    return ['span', attrs, text];
+  }
+};

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

@@ -0,0 +1,13 @@
+/**
+ * @name rule_node
+ */
+var hrDOM = ['hr'];
+export var rule = {
+  group: 'block',
+  parseDOM: [{
+    tag: 'hr'
+  }],
+  toDOM: function toDOM() {
+    return hrDOM;
+  }
+};

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

@@ -0,0 +1,51 @@
+import { uuid } from '../../utils/uuid';
+/**
+ * @name status_node
+ */
+
+export var status = {
+  inline: true,
+  group: 'inline',
+  selectable: true,
+  attrs: {
+    text: {
+      default: ''
+    },
+    color: {
+      default: ''
+    },
+    localId: {
+      default: uuid.generate()
+    },
+    style: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-node-type="status"]',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+      return {
+        text: dom.textContent.replace(/\n/, '').trim(),
+        color: dom.getAttribute('data-color'),
+        localId: uuid.generate(),
+        style: dom.getAttribute('data-style')
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var _node$attrs = node.attrs,
+        text = _node$attrs.text,
+        color = _node$attrs.color,
+        localId = _node$attrs.localId,
+        style = _node$attrs.style;
+    var attrs = {
+      'data-node-type': 'status',
+      'data-color': color,
+      'data-local-id': localId,
+      'data-style': style,
+      contenteditable: 'false'
+    };
+    return ['span', attrs, text];
+  }
+};

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

@@ -0,0 +1,238 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { B100, B50, B75, G200, G50, G75, hexToRgba, isRgb, N0, N20, N60, N800, P100, P50, P75, R100, R50, R75, rgbToHex, T100, T50, T75, Y200, Y50, Y75 } from '../../utils/colors';
+import { uuid } from '../../utils/uuid';
+export var tablePrefixSelector = 'pm-table';
+export var tableCellSelector = "".concat(tablePrefixSelector, "-cell-content-wrap");
+export var tableHeaderSelector = "".concat(tablePrefixSelector, "-header-content-wrap");
+export var tableCellContentWrapperSelector = "".concat(tablePrefixSelector, "-cell-nodeview-wrapper");
+export var tableCellContentDomSelector = "".concat(tablePrefixSelector, "-cell-nodeview-content-dom");
+var DEFAULT_TABLE_HEADER_CELL_BACKGROUND = N20.toLocaleLowerCase();
+export var getCellAttrs = function getCellAttrs(dom) {
+  var defaultValues = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var widthAttr = dom.getAttribute('data-colwidth');
+  var width = widthAttr && /^\d+(,\d+)*$/.test(widthAttr) ? widthAttr.split(',').map(function (str) {
+    return Number(str);
+  }) : null;
+  var colspan = Number(dom.getAttribute('colspan') || 1);
+  var backgroundColor = dom.style.backgroundColor;
+
+  if (backgroundColor && isRgb(backgroundColor)) {
+    var result = rgbToHex(backgroundColor);
+
+    if (result !== null) {
+      backgroundColor = result;
+    }
+  }
+
+  return {
+    colspan: colspan,
+    rowspan: Number(dom.getAttribute('rowspan') || 1),
+    colwidth: width && width.length === colspan ? width : null,
+    background: backgroundColor && backgroundColor !== defaultValues['background'] ? backgroundColor : null
+  };
+};
+
+/**
+ * gets cell dom attributes based on node attributes
+ * @returns CellDomAttrs
+ */
+export var getCellDomAttrs = function getCellDomAttrs(node) {
+  var attrs = {};
+  var nodeType = node.type.name;
+
+  if (node.attrs.colspan !== 1) {
+    attrs.colspan = node.attrs.colspan;
+  }
+
+  if (node.attrs.rowspan !== 1) {
+    attrs.rowspan = node.attrs.rowspan;
+  }
+
+  if (node.attrs.colwidth) {
+    attrs['data-colwidth'] = node.attrs.colwidth.join(',');
+  }
+
+  if (node.attrs.background) {
+    var background = node.attrs.background; // to ensure that we don't overwrite product's style:
+    // - it clears background color for <th> if its set to gray
+    // - it clears background color for <td> if its set to white
+
+    var ignored = nodeType === 'tableHeader' && background === tableBackgroundColorNames.get('light gray') || nodeType === 'tableCell' && background === tableBackgroundColorNames.get('white');
+
+    if (ignored) {
+      attrs.style = '';
+    } else {
+      var color = isRgb(background) ? rgbToHex(background) : background;
+      attrs.style = "".concat(attrs.style || '', "background-color: ").concat(color, ";");
+      attrs.colorname = tableBackgroundColorPalette.get(color);
+    }
+  }
+
+  if (nodeType === 'tableHeader') {
+    attrs.class = tableHeaderSelector;
+  } else {
+    attrs.class = tableCellSelector;
+  }
+
+  return attrs;
+};
+export var tableBackgroundColorPalette = new Map();
+export var tableBackgroundBorderColor = hexToRgba(N800, 0.12) || N0;
+export var tableBackgroundColorNames = new Map();
+[[N0, 'White'], [B50, 'Light blue'], [T50, 'Light teal'], [G50, 'Light green'], [Y50, 'Light yellow'], [R50, 'Light red'], [P50, 'Light purple'], [N20, 'Light gray'], [B75, 'Blue'], [T75, 'Teal'], [G75, 'Green'], [Y75, 'Yellow'], [R75, 'Red'], [P75, 'Purple'], [N60, 'Gray'], [B100, 'Dark blue'], [T100, 'Dark teal'], [G200, 'Dark green'], [Y200, 'Dark yellow'], [R100, 'Dark red'], [P100, 'Dark purple']].forEach(function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+      colorValue = _ref2[0],
+      colorName = _ref2[1];
+
+  tableBackgroundColorPalette.set(colorValue.toLowerCase(), colorName);
+  tableBackgroundColorNames.set(colorName.toLowerCase(), colorValue.toLowerCase());
+});
+
+// TODO: Fix any, potential issue. ED-5048
+var createTableSpec = function createTableSpec() {
+  var attrs = {
+    isNumberColumnEnabled: {
+      default: false
+    },
+    layout: {
+      default: 'default'
+    },
+    __autoSize: {
+      default: false
+    },
+    localId: {
+      default: ''
+    }
+  };
+  var tableNodeSpec = {
+    content: 'tableRow+',
+    attrs: attrs,
+    marks: 'unsupportedMark unsupportedNodeAttribute',
+    tableRole: 'table',
+    isolating: true,
+    selectable: false,
+    group: 'block',
+    parseDOM: [{
+      tag: 'table',
+      getAttrs: function getAttrs(node) {
+        var _dom$parentElement;
+
+        var dom = node;
+        var breakoutWrapper = (_dom$parentElement = dom.parentElement) === null || _dom$parentElement === void 0 ? void 0 : _dom$parentElement.parentElement;
+        return {
+          isNumberColumnEnabled: dom.getAttribute('data-number-column') === 'true' ? true : false,
+          layout: // copying from editor
+          dom.getAttribute('data-layout') || ( // copying from renderer
+          breakoutWrapper === null || breakoutWrapper === void 0 ? void 0 : breakoutWrapper.getAttribute('data-layout')) || 'default',
+          __autoSize: dom.getAttribute('data-autosize') === 'true' ? true : false,
+          localId: dom.getAttribute('data-table-local-id') || uuid.generate()
+        };
+      }
+    }],
+    toDOM: function toDOM(node) {
+      var attrs = {
+        'data-number-column': node.attrs.isNumberColumnEnabled,
+        'data-layout': node.attrs.layout,
+        'data-autosize': node.attrs.__autoSize,
+        'data-table-local-id': node.attrs.localId
+      };
+      return ['table', attrs, ['tbody', 0]];
+    }
+  };
+  return tableNodeSpec;
+};
+
+export var table = createTableSpec();
+
+var shouldIncludeAttribute = function shouldIncludeAttribute(key, value) {
+  return !key.startsWith('__') && (key !== 'localId' || !!value);
+};
+
+export var tableToJSON = function tableToJSON(node) {
+  return {
+    attrs: Object.keys(node.attrs).filter(function (key) {
+      return shouldIncludeAttribute(key, node.attrs[key]);
+    }).reduce(function (obj, key) {
+      obj[key] = node.attrs[key];
+      return obj;
+    }, {})
+  };
+};
+export var tableRow = {
+  selectable: false,
+  content: '(tableCell | tableHeader)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  tableRole: 'row',
+  parseDOM: [{
+    tag: 'tr'
+  }],
+  toDOM: function toDOM() {
+    return ['tr', 0];
+  }
+};
+var cellAttrs = {
+  colspan: {
+    default: 1
+  },
+  rowspan: {
+    default: 1
+  },
+  colwidth: {
+    default: null
+  },
+  background: {
+    default: null
+  }
+};
+export var tableCell = {
+  selectable: false,
+  content: '(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaSingle |  mediaGroup | decisionList | taskList | blockCard | embedCard | extension | nestedExpand | unsupportedBlock)+',
+  attrs: cellAttrs,
+  tableRole: 'cell',
+  marks: 'link alignment dataConsumer unsupportedMark unsupportedNodeAttribute',
+  isolating: true,
+  parseDOM: [// Ignore number cell copied from renderer
+  {
+    tag: '.ak-renderer-table-number-column',
+    ignore: true
+  }, {
+    tag: 'td',
+    getAttrs: function getAttrs(dom) {
+      return getCellAttrs(dom);
+    }
+  }],
+  toDOM: function toDOM(node) {
+    return ['td', getCellDomAttrs(node), 0];
+  }
+};
+export var toJSONTableCell = function toJSONTableCell(node) {
+  return {
+    attrs: Object.keys(node.attrs).reduce(function (obj, key) {
+      if (cellAttrs[key].default !== node.attrs[key]) {
+        obj[key] = node.attrs[key];
+      }
+
+      return obj;
+    }, {})
+  };
+};
+export var tableHeader = {
+  selectable: false,
+  content: '(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaSingle |  mediaGroup | decisionList | taskList | blockCard | embedCard | extension | nestedExpand)+',
+  attrs: cellAttrs,
+  tableRole: 'header_cell',
+  isolating: true,
+  marks: 'link alignment dataConsumer unsupportedMark unsupportedNodeAttribute',
+  parseDOM: [{
+    tag: 'th',
+    getAttrs: function getAttrs(dom) {
+      return getCellAttrs(dom, {
+        background: DEFAULT_TABLE_HEADER_CELL_BACKGROUND
+      });
+    }
+  }],
+  toDOM: function toDOM(node) {
+    return ['th', getCellDomAttrs(node), 0];
+  }
+};
+export var toJSONTableHeader = toJSONTableCell;