@atlaskit/adf-schema 19.2.0

package/dist/es2019/schema/marks/index.js

@@ -0,0 +1,17 @@
+export { em } from './em';
+export { code } from './code';
+export { strike } from './strike';
+export { strong } from './strong';
+export { underline } from './underline';
+export { link, toJSON as linkToJSON } from './link';
+export { typeAheadQuery } from './type-ahead-query';
+export { subsup } from './subsup';
+export { textColor, colorPalette, colorPaletteExtended } from './text-color';
+export { confluenceInlineComment } from './confluence-inline-comment';
+export { breakout } from './breakout';
+export { alignment, alignmentPositionMap } from './alignment';
+export { indentation } from './indentation';
+export { annotation, AnnotationMarkStates, buildDataAttributes as buildAnnotationMarkDataAttributes, AnnotationTypes } from './annotation';
+export { unsupportedMark } from './unsupported-mark';
+export { unsupportedNodeAttribute } from './unsupported-node-attributes';
+export { dataConsumer, toJSON as dataConsumerToJSON } from './data-consumer';

package/dist/es2019/schema/marks/link.js

@@ -0,0 +1,105 @@
+import { Fragment } from 'prosemirror-model';
+import { LINK, COLOR } from '../groups';
+import { isSafeUrl, normalizeUrl } from '../../utils/url';
+
+const getLinkAttrs = attribute => domNode => {
+  const dom = domNode;
+  const href = dom.getAttribute(attribute) || '';
+  const attrs = {
+    __confluenceMetadata: dom.hasAttribute('__confluenceMetadata') ? JSON.parse(dom.getAttribute('__confluenceMetadata') || '') : undefined
+  };
+
+  if (isSafeUrl(href)) {
+    attrs.href = normalizeUrl(href);
+  } else {
+    return false;
+  }
+
+  return attrs;
+};
+
+export const link = {
+  excludes: `${LINK} ${COLOR}`,
+  // ED-5844 No multiple links in media node
+  group: LINK,
+  attrs: {
+    href: {},
+    __confluenceMetadata: {
+      default: null
+    }
+  },
+  inclusive: false,
+  parseDOM: [{
+    tag: '[data-block-link]',
+    getAttrs: getLinkAttrs('data-block-link'),
+    contentElement: node => {
+      const clone = node.cloneNode(true);
+      clone.removeAttribute('data-block-link');
+      const wrapper = document.createElement('div');
+      wrapper.appendChild(clone);
+      return wrapper;
+    }
+  }, {
+    tag: 'a[href]',
+    context: 'paragraph/|heading/|mediaSingle/|taskItem/|decisionItem/',
+    getAttrs: getLinkAttrs('href')
+  }, {
+    /**
+     * When links aren't wrapped in a paragraph and due to
+     * the odd nature of how our schema is set up, prosemirror will
+     * add the link to the paragraph node itself where it should be on
+     * the text node, this satisfies our schema because link is allowed
+     * in many places (e.g. listitem)
+     * This change comes through via prosemirror-model@1.9.1
+     */
+    tag: 'a[href]',
+    getAttrs: getLinkAttrs('href'),
+    getContent: (node, schema) => {
+      if (node instanceof HTMLAnchorElement) {
+        const href = node.getAttribute('href');
+        const text = node.innerText;
+        return Fragment.from(schema.nodes.paragraph.createChecked(undefined, schema.text(text, [schema.marks.link.create({
+          href
+        })])));
+      }
+
+      return Fragment.empty;
+    }
+  }],
+
+  toDOM(node, isInline) {
+    const attrs = Object.keys(node.attrs).reduce((attrs, key) => {
+      if (key === '__confluenceMetadata') {
+        if (node.attrs[key] !== null) {
+          attrs[key] = JSON.stringify(node.attrs[key]);
+        }
+      } else if (key === 'href') {
+        attrs[key] = isSafeUrl(node.attrs[key]) ? node.attrs[key] : undefined;
+      } else {
+        attrs[key] = node.attrs[key];
+      }
+
+      return attrs;
+    }, {});
+
+    if (isInline) {
+      return ['a', attrs];
+    }
+
+    return ['a', { ...attrs,
+      class: 'blockLink'
+    }, 0];
+  }
+
+};
+const OPTIONAL_ATTRS = ['title', 'id', 'collection', 'occurrenceKey', '__confluenceMetadata'];
+export const toJSON = mark => ({
+  type: mark.type.name,
+  attrs: Object.keys(mark.attrs).reduce((attrs, key) => {
+    if (OPTIONAL_ATTRS.indexOf(key) === -1 || mark.attrs[key] !== null) {
+      attrs[key] = mark.attrs[key];
+    }
+
+    return attrs;
+  }, {})
+});

package/dist/es2019/schema/marks/strike.js

@@ -0,0 +1,24 @@
+import { FONT_STYLE } from '../groups';
+/**
+ * @name strike_mark
+ */
+
+export const strike = {
+  inclusive: true,
+  group: FONT_STYLE,
+  parseDOM: [{
+    tag: 'strike'
+  }, {
+    tag: 's'
+  }, {
+    tag: 'del'
+  }, {
+    style: 'text-decoration',
+    getAttrs: value => value === 'line-through' && null
+  }],
+
+  toDOM() {
+    return ['s'];
+  }
+
+};

package/dist/es2019/schema/marks/strong.js

@@ -0,0 +1,40 @@
+import { FONT_STYLE } from '../groups';
+/**
+ * @name strong_mark
+ */
+
+const strongDOM = ['strong'];
+export const strong = {
+  inclusive: true,
+  group: FONT_STYLE,
+  parseDOM: [{
+    tag: 'strong'
+  }, // This works around a Google Docs misbehavior where
+  // pasted content will be inexplicably wrapped in `<b>`
+  // tags with a font-weight normal.
+  {
+    tag: 'b',
+
+    getAttrs(node) {
+      const element = node;
+      return element.style.fontWeight !== 'normal' && null;
+    }
+
+  }, {
+    tag: 'span',
+
+    getAttrs(node) {
+      const element = node;
+      const {
+        fontWeight
+      } = element.style;
+      return typeof fontWeight === 'string' && (fontWeight === 'bold' || fontWeight === 'bolder' || /^(bold(er)?|[5-9]\d{2,})$/.test(fontWeight)) && null;
+    }
+
+  }],
+
+  toDOM() {
+    return strongDOM;
+  }
+
+};

package/dist/es2019/schema/marks/subsup.js

@@ -0,0 +1,51 @@
+import { FONT_STYLE } from '../groups';
+
+function getAttrFromVerticalAlign(node) {
+  if (node.style.verticalAlign) {
+    const type = node.style.verticalAlign.slice(0, 3);
+
+    if (type === 'sub' || type === 'sup') {
+      return {
+        type
+      };
+    }
+  }
+
+  return false;
+}
+
+export const subsup = {
+  inclusive: true,
+  group: FONT_STYLE,
+  attrs: {
+    type: {
+      default: 'sub'
+    }
+  },
+  parseDOM: [{
+    tag: 'sub',
+    attrs: {
+      type: 'sub'
+    }
+  }, {
+    tag: 'sup',
+    attrs: {
+      type: 'sup'
+    }
+  }, {
+    // Special case for pasting from Google Docs
+    // Google Docs uses vertical align to denote subscript and super script
+    tag: 'span',
+    style: 'vertical-align=super',
+    getAttrs: node => getAttrFromVerticalAlign(node)
+  }, {
+    tag: 'span',
+    style: 'vertical-align=sub',
+    getAttrs: node => getAttrFromVerticalAlign(node)
+  }],
+
+  toDOM(mark) {
+    return [mark.attrs.type];
+  }
+
+};

package/dist/es2019/schema/marks/text-color.js

@@ -0,0 +1,67 @@
+import { COLOR } from '../groups';
+import { rgbToHex, N0, N80, P50, P300, P500, T75, T300, T500, G75, G300, G500, R75, R300, R500, Y75, Y200, Y400, B75, B100, B500 } from '../../utils/colors';
+const colorArrayPalette = [// default row
+// [N800, default],
+[N80, 'Light gray'], [P300, 'Purple'], [T300, 'Teal'], [G300, 'Green'], [R300, 'Red'], [Y400, 'Orange']]; // used for extended palette in text color picker
+
+const colorArrayPaletteExtended = [// default row - first color is added programatically
+// [N800, 'Squid ink'], // default dark gray
+[B100, 'Blue'], // Arvo breeze
+[T300, 'Teal'], // Tamarama
+[G300, 'Green'], // Fine pine
+[Y200, 'Yellow'], // Pub mix
+[R300, 'Red'], // Poppy surprise
+[P300, 'Purple'], // Da' juice
+// row 2
+[N80, 'Light gray'], // Spooky ghost
+[B500, 'Dark blue'], // Chore coat
+[T500, 'Dark teal'], // Shabby chic
+[G500, 'Dark green'], // Keen green
+[Y400, 'Orange'], // Cheezy blasters
+[R500, 'Dark red'], // Dragon's blood
+[P500, 'Dark purple'], // Prince
+// row 3
+[N0, 'White'], [B75, 'Light blue'], // Schwag
+[T75, 'Light teal'], // Arctic chill
+[G75, 'Light green'], // Mintie
+[Y75, 'Light yellow'], // Dandelion whisper
+[R75, 'Light red'], // Bondi sunburn
+[P50, 'Light purple'] // Lavender secret
+]; // @see https://product-fabric.atlassian.net/wiki/spaces/E/pages/55979455/Colour+picker+decisions#Colourpickerdecisions-Visualdesigndecisions
+
+export const colorPalette = new Map();
+export const colorPaletteExtended = new Map();
+colorArrayPalette.forEach(([color, label]) => colorPalette.set(color.toLowerCase(), label));
+colorArrayPaletteExtended.forEach(([color, label]) => colorPaletteExtended.set(color.toLowerCase(), label));
+export const textColor = {
+  attrs: {
+    color: {}
+  },
+  inclusive: true,
+  group: COLOR,
+  parseDOM: [{
+    style: 'color',
+    getAttrs: maybeValue => {
+      const value = maybeValue;
+      let hexColor;
+
+      if (value.match(/^rgb/i)) {
+        hexColor = rgbToHex(value);
+      } else if (value[0] === '#') {
+        hexColor = value.toLowerCase();
+      } // else handle other colour formats
+
+
+      return hexColor && (colorPalette.has(hexColor) || colorPaletteExtended.has(hexColor)) ? {
+        color: hexColor
+      } : false;
+    }
+  }],
+
+  toDOM(mark) {
+    return ['span', {
+      style: `color: ${mark.attrs.color}`
+    }];
+  }
+
+};

package/dist/es2019/schema/marks/type-ahead-query.js

@@ -0,0 +1,23 @@
+import { SEARCH_QUERY } from '../groups';
+import { B400 } from '../../utils/colors';
+export const typeAheadQuery = {
+  inclusive: true,
+  group: SEARCH_QUERY,
+  parseDOM: [{
+    tag: 'span[data-type-ahead-query]'
+  }],
+
+  toDOM(node) {
+    return ['span', {
+      'data-type-ahead-query': 'true',
+      'data-trigger': node.attrs.trigger,
+      style: `color: ${B400}`
+    }];
+  },
+
+  attrs: {
+    trigger: {
+      default: ''
+    }
+  }
+};

package/dist/es2019/schema/marks/underline.js

@@ -0,0 +1,20 @@
+import { FONT_STYLE } from '../groups';
+/**
+ * @name underline_mark
+ */
+
+export const underline = {
+  inclusive: true,
+  group: FONT_STYLE,
+  parseDOM: [{
+    tag: 'u'
+  }, {
+    style: 'text-decoration',
+    getAttrs: value => value === 'underline' && null
+  }],
+
+  toDOM() {
+    return ['u'];
+  }
+
+};

package/dist/es2019/schema/marks/unsupported-mark.js

@@ -0,0 +1,9 @@
+export const unsupportedMark = {
+  toDOM() {
+    return ['span'];
+  },
+
+  attrs: {
+    originalValue: {}
+  }
+};

package/dist/es2019/schema/marks/unsupported-node-attributes.js

@@ -0,0 +1,10 @@
+export const unsupportedNodeAttribute = {
+  toDOM() {
+    return ['span'];
+  },
+
+  attrs: {
+    type: {},
+    unsupported: {}
+  }
+};

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

@@ -0,0 +1,50 @@
+/**
+ * @name blockCard_node
+ */
+export const blockCard = {
+  inline: false,
+  group: 'block',
+  draggable: true,
+  selectable: true,
+  attrs: {
+    url: {
+      default: null
+    },
+    data: {
+      default: null
+    }
+  },
+  parseDOM: [{
+    tag: 'a[data-block-card]',
+    // bump priority higher than hyperlink
+    priority: 100,
+    getAttrs: dom => {
+      const anchor = dom;
+      const data = anchor.getAttribute('data-card-data');
+      return {
+        url: anchor.getAttribute('href') || null,
+        data: data ? JSON.parse(data) : null
+      };
+    }
+  }, {
+    tag: 'div[data-block-card]',
+    getAttrs: dom => {
+      const anchor = dom;
+      const data = anchor.getAttribute('data-card-data');
+      return {
+        url: anchor.getAttribute('data-card-url') || null,
+        data: data ? JSON.parse(data) : null
+      };
+    }
+  }],
+
+  toDOM(node) {
+    const attrs = {
+      'data-block-card': '',
+      href: node.attrs.url || '',
+      'data-card-data': node.attrs.data ? JSON.stringify(node.attrs.data) : ''
+    };
+    return ['a', attrs];
+  }
+
+};

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

@@ -0,0 +1,17 @@
+/**
+ * @name blockquote_node
+ */
+export const blockquote = {
+  content: '(paragraph | unsupportedBlock)+',
+  group: 'block',
+  defining: true,
+  selectable: false,
+  parseDOM: [{
+    tag: 'blockquote'
+  }],
+
+  toDOM() {
+    return ['blockquote', 0];
+  }
+
+};