@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,46 @@
+import { getExtensionAttrs } from '../../utils/extensions';
+
+const createInlineExtensionNodeSpec = () => {
+  const nodeSpec = {
+    inline: true,
+    group: 'inline',
+    selectable: true,
+    attrs: {
+      extensionType: {
+        default: ''
+      },
+      extensionKey: {
+        default: ''
+      },
+      parameters: {
+        default: null
+      },
+      text: {
+        default: null
+      },
+      localId: {
+        default: null
+      }
+    },
+    parseDOM: [{
+      tag: 'span[data-extension-type]',
+      getAttrs: domNode => getExtensionAttrs(domNode, true)
+    }],
+
+    toDOM(node) {
+      const attrs = {
+        '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-local-id:': node.attrs.localId,
+        contenteditable: 'false'
+      };
+      return ['span', attrs];
+    }
+
+  };
+  return nodeSpec;
+};
+
+export const inlineExtension = createInlineExtensionNodeSpec();

package/dist/es2019/schema/nodes/layout-column.js

@@ -0,0 +1,49 @@
+/**
+ * @name layoutColumn_node
+ */
+export const layoutColumn = {
+  content: '(block|unsupportedBlock)+',
+  isolating: true,
+  marks: 'link alignment indentation dataConsumer unsupportedMark unsupportedNodeAttribute',
+  selectable: false,
+  attrs: {
+    width: {
+      default: undefined
+    }
+  },
+  parseDOM: [{
+    context: 'layoutColumn//',
+    tag: 'div[data-layout-column]',
+    skip: true
+  }, {
+    tag: 'div[data-layout-column]',
+    getAttrs: domNode => {
+      const dom = domNode;
+      return {
+        width: Number(dom.getAttribute('data-column-width')) || undefined
+      };
+    }
+  }],
+
+  toDOM(node) {
+    const attrs = {
+      'data-layout-column': 'true'
+    };
+    const {
+      width
+    } = node.attrs;
+
+    if (width) {
+      attrs['style'] = `flex-basis: ${width}%`;
+      attrs['data-column-width'] = width;
+    } // We need to apply a attribute to the inner most child to help
+    // ProseMirror identify its boundaries better.
+
+
+    const contentAttrs = {
+      'data-layout-content': 'true'
+    };
+    return ['div', attrs, ['div', contentAttrs, 0]];
+  }
+
+};

package/dist/es2019/schema/nodes/layout-section.js

@@ -0,0 +1,56 @@
+/**
+ * @name layoutSection_node
+ */
+
+/**
+ * Need duplicate `type` and `marks` to make both validator and json-schema satisfied
+ */
+
+/**
+ * @name layoutSection_full_node
+ */
+
+/**
+ * @stage 0
+ * @name layoutSection_with_single_column_node
+ */
+export const layoutSection = {
+  content: '(layoutColumn | unsupportedBlock){1,3} unsupportedBlock*',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  isolating: true,
+  parseDOM: [{
+    context: 'layoutSection//|layoutColumn//',
+    tag: 'div[data-layout-section]',
+    skip: true
+  }, {
+    tag: 'div[data-layout-section]'
+  }],
+
+  toDOM() {
+    const attrs = {
+      'data-layout-section': 'true'
+    };
+    return ['div', attrs, 0];
+  }
+
+};
+export const layoutSectionWithSingleColumn = {
+  content: '(layoutColumn | unsupportedBlock){1,3} unsupportedBlock*',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  isolating: true,
+  parseDOM: [{
+    context: 'layoutSection//|layoutColumn//',
+    tag: 'div[data-layout-section]',
+    skip: true
+  }, {
+    tag: 'div[data-layout-section]'
+  }],
+
+  toDOM() {
+    const attrs = {
+      'data-layout-section': 'true'
+    };
+    return ['div', attrs, 0];
+  }
+
+};

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

@@ -0,0 +1,20 @@
+// eslint-disable-next-line import/no-cycle
+// eslint-disable-next-line import/no-cycle
+
+/**
+ * @name listItem_node
+ */
+export const listItem = {
+  content: '(paragraph | mediaSingle | codeBlock) (paragraph | bulletList | orderedList | mediaSingle | codeBlock)*',
+  marks: 'link unsupportedMark unsupportedNodeAttribute',
+  defining: true,
+  selectable: false,
+  parseDOM: [{
+    tag: 'li'
+  }],
+
+  toDOM() {
+    return ['li', 0];
+  }
+
+};

package/dist/es2019/schema/nodes/media-group.js

@@ -0,0 +1,23 @@
+/**
+ * @name mediaGroup_node
+ */
+export const mediaGroup = {
+  inline: false,
+  group: 'block',
+  content: '(media|unsupportedBlock)+',
+  attrs: {},
+  marks: 'unsupportedMark unsupportedNodeAttribute link',
+  selectable: false,
+  parseDOM: [{
+    tag: 'div[data-node-type="mediaGroup"]'
+  }, {
+    tag: 'div[class="MediaGroup"]'
+  }],
+
+  toDOM() {
+    return ['div', {
+      'data-node-type': 'mediaGroup'
+    }, 0];
+  }
+
+};

package/dist/es2019/schema/nodes/media-inline.js

@@ -0,0 +1,2 @@
+import { createMediaSpec, defaultAttrs } from './media';
+export const mediaInline = createMediaSpec(defaultAttrs, true);

package/dist/es2019/schema/nodes/media-single.js

@@ -0,0 +1,77 @@
+/**
+ * @name mediaSingle_node
+ * @additionalProperties true
+ */
+
+/**
+ * @additionalProperties true
+ */
+
+/**
+ * @name mediaSingle_full_node
+ */
+
+/**
+ * @additionalProperties true
+ */
+
+/**
+ * @name mediaSingle_caption_node
+ * @stage 0
+ */
+export const defaultAttrs = {
+  width: {
+    default: null
+  },
+  // null makes small images to have original size by default
+  layout: {
+    default: 'center'
+  }
+};
+export const mediaSingle = {
+  inline: false,
+  group: 'block',
+  selectable: true,
+  atom: true,
+  content: 'media|unsupportedBlock+|media unsupportedBlock+',
+  attrs: defaultAttrs,
+  marks: 'unsupportedMark unsupportedNodeAttribute link',
+  parseDOM: [{
+    tag: 'div[data-node-type="mediaSingle"]',
+    getAttrs: dom => ({
+      layout: dom.getAttribute('data-layout') || 'center',
+      width: Number(dom.getAttribute('data-width')) || null
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      layout,
+      width
+    } = node.attrs;
+    const attrs = {
+      'data-node-type': 'mediaSingle',
+      'data-layout': layout,
+      'data-width': ''
+    };
+
+    if (width) {
+      attrs['data-width'] = isFinite(width) && Math.floor(width) === width ? width : width.toFixed(2);
+    }
+
+    return ['div', attrs, 0];
+  }
+
+};
+export const mediaSingleWithCaption = { ...mediaSingle,
+  content: 'media|unsupportedBlock+|media (caption|unsupportedBlock) unsupportedBlock*'
+};
+export const toJSON = node => ({
+  attrs: Object.keys(node.attrs).reduce((obj, key) => {
+    if (node.attrs[key] !== null) {
+      obj[key] = node.attrs[key];
+    }
+
+    return obj;
+  }, {})
+});

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

@@ -0,0 +1,165 @@
+import { N30 } from '../../utils/colors';
+export const defaultAttrs = {
+  id: {
+    default: ''
+  },
+  type: {
+    default: 'file'
+  },
+  collection: {
+    default: ''
+  },
+  occurrenceKey: {
+    default: null
+  },
+  alt: {
+    default: ''
+  },
+  width: {
+    default: null
+  },
+  height: {
+    default: null
+  },
+  url: {
+    default: null
+  },
+  __fileName: {
+    default: null
+  },
+  __fileSize: {
+    default: null
+  },
+  __fileMimeType: {
+    default: null
+  },
+  __displayType: {
+    default: null
+  },
+  __contextId: {
+    default: null
+  },
+  __external: {
+    default: false
+  }
+};
+export const createMediaSpec = (attributes, inline = false) => {
+  const domNodeType = inline ? 'span' : 'div';
+  const nodeName = inline ? 'mediaInline' : 'media';
+  return {
+    selectable: true,
+    inline,
+    group: inline ? 'inline' : undefined,
+    attrs: attributes,
+    parseDOM: [{
+      tag: `${domNodeType}[data-node-type="${nodeName}"]`,
+      getAttrs: dom => {
+        const attrs = {};
+
+        if (attributes) {
+          Object.keys(attributes).forEach(k => {
+            const key = camelCaseToKebabCase(k).replace(/^__/, '');
+            const value = dom.getAttribute(`data-${key}`) || '';
+
+            if (value) {
+              attrs[k] = value;
+            }
+          });
+        } // Need to do validation & type conversion manually
+
+
+        if (attrs.__fileSize) {
+          attrs.__fileSize = +attrs.__fileSize;
+        }
+
+        const width = Number(attrs.width);
+
+        if (typeof width !== 'undefined' && !isNaN(width)) {
+          attrs.width = width;
+        }
+
+        const height = Number(attrs.height);
+
+        if (typeof height !== 'undefined' && !isNaN(height)) {
+          attrs.height = height;
+        }
+
+        return attrs;
+      }
+    }, // Don't match data URI
+    {
+      tag: 'img[src^="data:image"]',
+      ignore: true
+    }, {
+      tag: 'img:not(.smart-link-icon)',
+      getAttrs: dom => {
+        return {
+          type: 'external',
+          url: dom.getAttribute('src') || '',
+          alt: dom.getAttribute('alt') || ''
+        };
+      }
+    }],
+
+    toDOM(node) {
+      const attrs = {
+        'data-id': node.attrs.id,
+        'data-node-type': `${nodeName}`,
+        'data-type': node.attrs.type,
+        'data-collection': node.attrs.collection,
+        'data-occurrence-key': node.attrs.occurrenceKey,
+        'data-width': node.attrs.width,
+        'data-height': node.attrs.height,
+        'data-url': node.attrs.url,
+        'data-alt': node.attrs.alt,
+        // toDOM is used for static rendering as well as editor rendering. This comes into play for
+        // emails, copy/paste, etc, so the title and styling here *is* useful (despite a React-based
+        // node view being used for editing).
+        title: 'Attachment',
+        // Manually kept in sync with the style of media cards. The goal is to render a plain gray
+        // rectangle that provides an affordance for media.
+        style: `display: inline-block; border-radius: 3px; background: ${N30}; box-shadow: 0 1px 1px rgba(9, 30, 66, 0.2), 0 0 1px 0 rgba(9, 30, 66, 0.24);`
+      };
+      copyPrivateAttributes(node.attrs, attrs, key => `data-${camelCaseToKebabCase(key.slice(2))}`);
+      return [`${domNodeType}`, attrs];
+    }
+
+  };
+};
+export const media = createMediaSpec(defaultAttrs);
+export const camelCaseToKebabCase = str => str.replace(/([^A-Z]+)([A-Z])/g, (_, x, y) => `${x}-${y.toLowerCase()}`);
+export const copyPrivateAttributes = (from, to, map) => {
+  if (media.attrs) {
+    Object.keys(media.attrs).forEach(key => {
+      if (key[0] === '_' && key[1] === '_' && from[key]) {
+        to[map ? map(key) : key] = from[key];
+      }
+    });
+  }
+};
+/**
+ * There's no concept of optional property in ProseMirror. It sets value as `null`
+ * when there's no use of any property. We are filtering out all private & optional attrs here.
+ */
+
+const optionalAttributes = ['occurrenceKey', 'width', 'height', 'url', 'alt'];
+const externalOnlyAttributes = ['type', 'url', 'width', 'height', 'alt'];
+export const toJSON = node => ({
+  attrs: Object.keys(node.attrs).filter(key => !(key[0] === '_' && key[1] === '_')).reduce((obj, key) => {
+    if (node.attrs.type === 'external' && externalOnlyAttributes.indexOf(key) === -1) {
+      return obj;
+    }
+
+    if (optionalAttributes.indexOf(key) > -1 && (node.attrs[key] === null || node.attrs[key] === '')) {
+      return obj;
+    }
+
+    if (['width', 'height'].indexOf(key) !== -1) {
+      obj[key] = Number(node.attrs[key]);
+      return obj;
+    }
+
+    obj[key] = node.attrs[key];
+    return obj;
+  }, {})
+});