@atlaskit/adf-schema 19.2.0

package/dist/esm/schema/marks/indentation.js

@@ -0,0 +1,23 @@
+import { ALIGNMENT, INDENTATION } from '../groups';
+export var indentation = {
+  excludes: "indentation ".concat(ALIGNMENT),
+  group: INDENTATION,
+  attrs: {
+    level: {}
+  },
+  parseDOM: [{
+    tag: 'div.fabric-editor-indentation-mark',
+    getAttrs: function getAttrs(dom) {
+      var level = +(dom.getAttribute('data-level') || '0');
+      return {
+        level: level > 6 ? 6 : level < 1 ? false : level
+      };
+    }
+  }],
+  toDOM: function toDOM(mark) {
+    return ['div', {
+      class: 'fabric-editor-block-mark fabric-editor-indentation-mark',
+      'data-level': mark.attrs.level
+    }, 0];
+  }
+};

package/dist/esm/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/esm/schema/marks/link.js

@@ -0,0 +1,113 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { Fragment } from 'prosemirror-model';
+import { LINK, COLOR } from '../groups';
+import { isSafeUrl, normalizeUrl } from '../../utils/url';
+
+var getLinkAttrs = function getLinkAttrs(attribute) {
+  return function (domNode) {
+    var dom = domNode;
+    var href = dom.getAttribute(attribute) || '';
+    var attrs = {
+      __confluenceMetadata: dom.hasAttribute('__confluenceMetadata') ? JSON.parse(dom.getAttribute('__confluenceMetadata') || '') : undefined
+    };
+
+    if (isSafeUrl(href)) {
+      attrs.href = normalizeUrl(href);
+    } else {
+      return false;
+    }
+
+    return attrs;
+  };
+};
+
+export var link = {
+  excludes: "".concat(LINK, " ").concat(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: function contentElement(node) {
+      var clone = node.cloneNode(true);
+      clone.removeAttribute('data-block-link');
+      var 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: function getContent(node, schema) {
+      if (node instanceof HTMLAnchorElement) {
+        var href = node.getAttribute('href');
+        var text = node.innerText;
+        return Fragment.from(schema.nodes.paragraph.createChecked(undefined, schema.text(text, [schema.marks.link.create({
+          href: href
+        })])));
+      }
+
+      return Fragment.empty;
+    }
+  }],
+  toDOM: function toDOM(node, isInline) {
+    var attrs = Object.keys(node.attrs).reduce(function (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', _objectSpread(_objectSpread({}, attrs), {}, {
+      class: 'blockLink'
+    }), 0];
+  }
+};
+var OPTIONAL_ATTRS = ['title', 'id', 'collection', 'occurrenceKey', '__confluenceMetadata'];
+export var toJSON = function toJSON(mark) {
+  return {
+    type: mark.type.name,
+    attrs: Object.keys(mark.attrs).reduce(function (attrs, key) {
+      if (OPTIONAL_ATTRS.indexOf(key) === -1 || mark.attrs[key] !== null) {
+        attrs[key] = mark.attrs[key];
+      }
+
+      return attrs;
+    }, {})
+  };
+};

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

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

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

@@ -0,0 +1,32 @@
+import { FONT_STYLE } from '../groups';
+/**
+ * @name strong_mark
+ */
+
+var strongDOM = ['strong'];
+export var 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: function getAttrs(node) {
+      var element = node;
+      return element.style.fontWeight !== 'normal' && null;
+    }
+  }, {
+    tag: 'span',
+    getAttrs: function getAttrs(node) {
+      var element = node;
+      var fontWeight = element.style.fontWeight;
+      return typeof fontWeight === 'string' && (fontWeight === 'bold' || fontWeight === 'bolder' || /^(bold(er)?|[5-9]\d{2,})$/.test(fontWeight)) && null;
+    }
+  }],
+  toDOM: function toDOM() {
+    return strongDOM;
+  }
+};

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

@@ -0,0 +1,53 @@
+import { FONT_STYLE } from '../groups';
+
+function getAttrFromVerticalAlign(node) {
+  if (node.style.verticalAlign) {
+    var type = node.style.verticalAlign.slice(0, 3);
+
+    if (type === 'sub' || type === 'sup') {
+      return {
+        type: type
+      };
+    }
+  }
+
+  return false;
+}
+
+export var 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: function getAttrs(node) {
+      return getAttrFromVerticalAlign(node);
+    }
+  }, {
+    tag: 'span',
+    style: 'vertical-align=sub',
+    getAttrs: function getAttrs(node) {
+      return getAttrFromVerticalAlign(node);
+    }
+  }],
+  toDOM: function toDOM(mark) {
+    return [mark.attrs.type];
+  }
+};

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

@@ -0,0 +1,78 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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';
+var 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
+
+var 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 var colorPalette = new Map();
+export var colorPaletteExtended = new Map();
+colorArrayPalette.forEach(function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+      color = _ref2[0],
+      label = _ref2[1];
+
+  return colorPalette.set(color.toLowerCase(), label);
+});
+colorArrayPaletteExtended.forEach(function (_ref3) {
+  var _ref4 = _slicedToArray(_ref3, 2),
+      color = _ref4[0],
+      label = _ref4[1];
+
+  return colorPaletteExtended.set(color.toLowerCase(), label);
+});
+export var textColor = {
+  attrs: {
+    color: {}
+  },
+  inclusive: true,
+  group: COLOR,
+  parseDOM: [{
+    style: 'color',
+    getAttrs: function getAttrs(maybeValue) {
+      var value = maybeValue;
+      var 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: function toDOM(mark) {
+    return ['span', {
+      style: "color: ".concat(mark.attrs.color)
+    }];
+  }
+};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+/**
+ * @name blockCard_node
+ */
+export var 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: function getAttrs(dom) {
+      var anchor = dom;
+      var data = anchor.getAttribute('data-card-data');
+      return {
+        url: anchor.getAttribute('href') || null,
+        data: data ? JSON.parse(data) : null
+      };
+    }
+  }, {
+    tag: 'div[data-block-card]',
+    getAttrs: function getAttrs(dom) {
+      var anchor = dom;
+      var data = anchor.getAttribute('data-card-data');
+      return {
+        url: anchor.getAttribute('data-card-url') || null,
+        data: data ? JSON.parse(data) : null
+      };
+    }
+  }],
+  toDOM: function toDOM(node) {
+    var attrs = {
+      'data-block-card': '',
+      href: node.attrs.url || '',
+      'data-card-data': node.attrs.data ? JSON.stringify(node.attrs.data) : ''
+    };
+    return ['a', attrs];
+  }
+};