@atlaskit/adf-schema 19.2.0

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

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

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

@@ -0,0 +1,58 @@
+/**
+ * @name nestedExpand_content
+ * @minItems 1
+ * @allowUnsupportedBlock true
+ */
+
+/**
+ * @name nestedExpand_node
+ */
+
+/**
+ * @name nestedExpand_with_no_marks_node
+ */
+export const 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: domNode => {
+      const dom = domNode;
+      return {
+        title: dom.getAttribute('data-title'),
+        __expanded: true
+      };
+    }
+  }],
+
+  toDOM(node) {
+    const attrs = {
+      'data-node-type': 'nestedExpand',
+      'data-title': node.attrs.title,
+      'data-expanded': node.attrs.__expanded
+    };
+    return ['div', attrs, 0];
+  }
+
+};

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

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

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

@@ -0,0 +1,79 @@
+export let 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 const 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: dom => ({
+      panelType: dom.getAttribute('data-panel-type'),
+      panelIcon: dom.getAttribute('data-panel-icon'),
+      panelColor: dom.getAttribute('data-panel-color')
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      panelType,
+      panelIcon,
+      panelColor
+    } = node.attrs;
+    const attrs = {
+      'data-panel-type': panelType,
+      'data-panel-icon': panelIcon,
+      'data-panel-color': panelColor
+    };
+    return ['div', attrs, ['div', {}, 0]];
+  }
+
+};
+export const panel = {
+  group: 'block',
+  content: '(paragraph | heading | bulletList | orderedList | blockCard | unsupportedBlock)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  attrs: {
+    panelType: {
+      default: 'info'
+    }
+  },
+  parseDOM: [{
+    tag: 'div[data-panel-type]',
+    getAttrs: dom => ({
+      panelType: dom.getAttribute('data-panel-type')
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      panelType
+    } = node.attrs;
+    const attrs = {
+      'data-panel-type': panelType
+    };
+    return ['div', attrs, ['div', {}, 0]];
+  }
+
+};

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

@@ -0,0 +1,39 @@
+/**
+ * @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
+ */
+const pDOM = ['p', 0];
+export const 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() {
+    return pDOM;
+  }
+
+};

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

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

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

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

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

@@ -0,0 +1,54 @@
+import { uuid } from '../../utils/uuid';
+/**
+ * @name status_node
+ */
+
+export const 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: domNode => {
+      const dom = domNode;
+      return {
+        text: dom.textContent.replace(/\n/, '').trim(),
+        color: dom.getAttribute('data-color'),
+        localId: uuid.generate(),
+        style: dom.getAttribute('data-style')
+      };
+    }
+  }],
+
+  toDOM(node) {
+    const {
+      text,
+      color,
+      localId,
+      style
+    } = node.attrs;
+    const attrs = {
+      'data-node-type': 'status',
+      'data-color': color,
+      'data-local-id': localId,
+      'data-style': style,
+      contenteditable: 'false'
+    };
+    return ['span', attrs, text];
+  }
+
+};

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

@@ -0,0 +1,222 @@
+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 const tablePrefixSelector = 'pm-table';
+export const tableCellSelector = `${tablePrefixSelector}-cell-content-wrap`;
+export const tableHeaderSelector = `${tablePrefixSelector}-header-content-wrap`;
+export const tableCellContentWrapperSelector = `${tablePrefixSelector}-cell-nodeview-wrapper`;
+export const tableCellContentDomSelector = `${tablePrefixSelector}-cell-nodeview-content-dom`;
+const DEFAULT_TABLE_HEADER_CELL_BACKGROUND = N20.toLocaleLowerCase();
+export const getCellAttrs = (dom, defaultValues = {}) => {
+  const widthAttr = dom.getAttribute('data-colwidth');
+  const width = widthAttr && /^\d+(,\d+)*$/.test(widthAttr) ? widthAttr.split(',').map(str => Number(str)) : null;
+  const colspan = Number(dom.getAttribute('colspan') || 1);
+  let {
+    backgroundColor
+  } = dom.style;
+
+  if (backgroundColor && isRgb(backgroundColor)) {
+    const result = rgbToHex(backgroundColor);
+
+    if (result !== null) {
+      backgroundColor = result;
+    }
+  }
+
+  return {
+    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 const getCellDomAttrs = node => {
+  const attrs = {};
+  const 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) {
+    const {
+      background
+    } = node.attrs; // 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
+
+    const ignored = nodeType === 'tableHeader' && background === tableBackgroundColorNames.get('light gray') || nodeType === 'tableCell' && background === tableBackgroundColorNames.get('white');
+
+    if (ignored) {
+      attrs.style = '';
+    } else {
+      const color = isRgb(background) ? rgbToHex(background) : background;
+      attrs.style = `${attrs.style || ''}background-color: ${color};`;
+      attrs.colorname = tableBackgroundColorPalette.get(color);
+    }
+  }
+
+  if (nodeType === 'tableHeader') {
+    attrs.class = tableHeaderSelector;
+  } else {
+    attrs.class = tableCellSelector;
+  }
+
+  return attrs;
+};
+export const tableBackgroundColorPalette = new Map();
+export const tableBackgroundBorderColor = hexToRgba(N800, 0.12) || N0;
+export const 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(([colorValue, colorName]) => {
+  tableBackgroundColorPalette.set(colorValue.toLowerCase(), colorName);
+  tableBackgroundColorNames.set(colorName.toLowerCase(), colorValue.toLowerCase());
+});
+
+// TODO: Fix any, potential issue. ED-5048
+const createTableSpec = () => {
+  const attrs = {
+    isNumberColumnEnabled: {
+      default: false
+    },
+    layout: {
+      default: 'default'
+    },
+    __autoSize: {
+      default: false
+    },
+    localId: {
+      default: ''
+    }
+  };
+  const tableNodeSpec = {
+    content: 'tableRow+',
+    attrs: attrs,
+    marks: 'unsupportedMark unsupportedNodeAttribute',
+    tableRole: 'table',
+    isolating: true,
+    selectable: false,
+    group: 'block',
+    parseDOM: [{
+      tag: 'table',
+      getAttrs: node => {
+        var _dom$parentElement;
+
+        const dom = node;
+        const 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(node) {
+      const 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 const table = createTableSpec();
+
+const shouldIncludeAttribute = (key, value) => !key.startsWith('__') && (key !== 'localId' || !!value);
+
+export const tableToJSON = node => ({
+  attrs: Object.keys(node.attrs).filter(key => shouldIncludeAttribute(key, node.attrs[key])).reduce((obj, key) => {
+    obj[key] = node.attrs[key];
+    return obj;
+  }, {})
+});
+export const tableRow = {
+  selectable: false,
+  content: '(tableCell | tableHeader)+',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  tableRole: 'row',
+  parseDOM: [{
+    tag: 'tr'
+  }],
+
+  toDOM() {
+    return ['tr', 0];
+  }
+
+};
+const cellAttrs = {
+  colspan: {
+    default: 1
+  },
+  rowspan: {
+    default: 1
+  },
+  colwidth: {
+    default: null
+  },
+  background: {
+    default: null
+  }
+};
+export const 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: dom => getCellAttrs(dom)
+  }],
+  toDOM: node => ['td', getCellDomAttrs(node), 0]
+};
+export const toJSONTableCell = node => ({
+  attrs: Object.keys(node.attrs).reduce((obj, key) => {
+    if (cellAttrs[key].default !== node.attrs[key]) {
+      obj[key] = node.attrs[key];
+    }
+
+    return obj;
+  }, {})
+});
+export const 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: dom => getCellAttrs(dom, {
+      background: DEFAULT_TABLE_HEADER_CELL_BACKGROUND
+    })
+  }],
+  toDOM: node => ['th', getCellDomAttrs(node), 0]
+};
+export const toJSONTableHeader = toJSONTableCell;