@atlaskit/adf-schema 19.2.0

package/dist/cjs/schema/inline-nodes.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.inlineNodes = void 0;
+
+var nodes = _interopRequireWildcard(require("./nodes"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var typedNodes = nodes;
+var inlineNodes = new Set(Object.keys(typedNodes).filter(function (key) {
+  return typedNodes[key] && typedNodes[key].group === 'inline';
+}));
+exports.inlineNodes = inlineNodes;

package/dist/cjs/schema/jira-schema.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = makeSchema;
+exports.isSchemaWithLists = isSchemaWithLists;
+exports.isSchemaWithMentions = isSchemaWithMentions;
+exports.isSchemaWithEmojis = isSchemaWithEmojis;
+exports.isSchemaWithLinks = isSchemaWithLinks;
+exports.isSchemaWithAdvancedTextFormattingMarks = isSchemaWithAdvancedTextFormattingMarks;
+exports.isSchemaWithSubSupMark = isSchemaWithSubSupMark;
+exports.isSchemaWithCodeBlock = isSchemaWithCodeBlock;
+exports.isSchemaWithBlockQuotes = isSchemaWithBlockQuotes;
+exports.isSchemaWithMedia = isSchemaWithMedia;
+exports.isSchemaWithTextColor = isSchemaWithTextColor;
+exports.isSchemaWithTables = isSchemaWithTables;
+
+var _createSchema = require("./create-schema");
+
+function makeSchema(config) {
+  var nodes = ['doc', 'paragraph', 'text', 'hardBreak', 'heading', 'rule'];
+  var marks = ['strong', 'em', 'underline', 'typeAheadQuery', 'unsupportedMark', 'unsupportedNodeAttribute'];
+
+  if (config.allowLinks) {
+    marks.push('link');
+  }
+
+  if (config.allowLists) {
+    nodes.push('orderedList', 'bulletList', 'listItem');
+  }
+
+  if (config.allowMentions) {
+    nodes.push('mention');
+    marks.push('mentionQuery');
+  }
+
+  if (config.allowEmojis) {
+    nodes.push('emoji');
+  }
+
+  if (config.allowAdvancedTextFormatting) {
+    marks.push('strike', 'code');
+  }
+
+  if (config.allowSubSup) {
+    marks.push('subsup');
+  }
+
+  if (config.allowCodeBlock) {
+    nodes.push('codeBlock');
+  }
+
+  if (config.allowBlockQuote) {
+    nodes.push('blockquote');
+  }
+
+  if (config.allowMedia) {
+    nodes.push('mediaGroup', 'mediaSingle', 'media');
+  }
+
+  if (config.allowTextColor) {
+    marks.push('textColor');
+  }
+
+  if (config.allowTables) {
+    nodes.push('table', 'tableCell', 'tableHeader', 'tableRow');
+  }
+
+  return (0, _createSchema.createSchema)({
+    nodes: nodes,
+    marks: marks
+  });
+}
+
+function isSchemaWithLists(schema) {
+  return !!schema.nodes.bulletList;
+}
+
+function isSchemaWithMentions(schema) {
+  return !!schema.nodes.mention;
+}
+
+function isSchemaWithEmojis(schema) {
+  return !!schema.nodes.emoji;
+}
+
+function isSchemaWithLinks(schema) {
+  return !!schema.marks.link;
+}
+
+function isSchemaWithAdvancedTextFormattingMarks(schema) {
+  return !!schema.marks.code && !!schema.marks.strike;
+}
+
+function isSchemaWithSubSupMark(schema) {
+  return !!schema.marks.subsup;
+}
+
+function isSchemaWithCodeBlock(schema) {
+  return !!schema.nodes.codeBlock;
+}
+
+function isSchemaWithBlockQuotes(schema) {
+  return !!schema.nodes.blockquote;
+}
+
+function isSchemaWithMedia(schema) {
+  return !!schema.nodes.mediaGroup && !!schema.nodes.media;
+}
+
+function isSchemaWithTextColor(schema) {
+  return !!schema.marks.textColor;
+}
+
+function isSchemaWithTables(schema) {
+  return !!schema.nodes.table && !!schema.nodes.tableCell && !!schema.nodes.tableHeader && !!schema.nodes.tableRow;
+}

package/dist/cjs/schema/marks/alignment.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alignment = exports.alignmentPositionMap = void 0;
+
+var _groups = require("../groups");
+
+/** TODO: Flip these positions for RTL */
+var alignmentPositionMap = {
+  end: 'right',
+  right: 'end',
+  center: 'center'
+};
+exports.alignmentPositionMap = alignmentPositionMap;
+var alignment = {
+  excludes: "alignment ".concat(_groups.INDENTATION),
+  group: _groups.ALIGNMENT,
+  attrs: {
+    align: {}
+  },
+  parseDOM: [{
+    tag: 'div.fabric-editor-block-mark',
+    getAttrs: function getAttrs(dom) {
+      var align = dom.getAttribute('data-align');
+      return align ? {
+        align: align
+      } : false;
+    }
+  }],
+  toDOM: function toDOM(mark) {
+    return ['div', {
+      class: "fabric-editor-block-mark fabric-editor-align-".concat(mark.attrs.align),
+      'data-align': mark.attrs.align
+    }, 0];
+  }
+};
+exports.alignment = alignment;

package/dist/cjs/schema/marks/annotation.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildDataAttributes = buildDataAttributes;
+exports.annotation = exports.AnnotationMarkStates = exports.AnnotationTypes = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@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) { (0, _defineProperty2.default)(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; }
+
+/**
+ * @name annotation_mark
+ */
+var AnnotationTypes;
+exports.AnnotationTypes = AnnotationTypes;
+
+(function (AnnotationTypes) {
+  AnnotationTypes["INLINE_COMMENT"] = "inlineComment";
+})(AnnotationTypes || (exports.AnnotationTypes = AnnotationTypes = {}));
+
+var AnnotationMarkStates;
+exports.AnnotationMarkStates = AnnotationMarkStates;
+
+(function (AnnotationMarkStates) {
+  AnnotationMarkStates["RESOLVED"] = "resolved";
+  AnnotationMarkStates["ACTIVE"] = "active";
+})(AnnotationMarkStates || (exports.AnnotationMarkStates = AnnotationMarkStates = {}));
+
+function buildDataAttributes(_ref) {
+  var id = _ref.id,
+      annotationType = _ref.annotationType,
+      state = _ref.state;
+  var data = {
+    'data-mark-type': 'annotation',
+    'data-mark-annotation-type': annotationType,
+    'data-id': id
+  };
+
+  if (state) {
+    return _objectSpread(_objectSpread({}, data), {}, {
+      'data-mark-annotation-state': state
+    });
+  }
+
+  return data;
+}
+
+var annotation = {
+  inclusive: false,
+  group: 'annotation',
+  excludes: '',
+  attrs: {
+    id: {
+      default: ''
+    },
+    annotationType: {
+      default: AnnotationTypes.INLINE_COMMENT
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-mark-type="annotation"]',
+    mark: 'annotation',
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+      var attrs = {
+        id: dom.getAttribute('data-id'),
+        annotationType: dom.getAttribute('data-mark-annotation-type')
+      };
+      return attrs;
+    }
+  }],
+  toDOM: function toDOM(node) {
+    /*
+      Data attributes on the DOM node are a temporary means of
+      incrementally switching over to the Annotation mark. Once renderer
+      provides native support for inline comments the data attributes on the
+      DOM nodes will be removed.
+    */
+    return ['span', _objectSpread({
+      // Prettier will remove the quotes around class. This would cause some browsers
+      // to not add this attribute properly, as its a reserved word.
+      // prettier-ignore
+      'class': 'fabric-editor-annotation'
+    }, buildDataAttributes({
+      id: node.attrs.id,
+      annotationType: node.attrs.annotationType
+    })), 0];
+  }
+};
+exports.annotation = annotation;

package/dist/cjs/schema/marks/breakout.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.breakout = void 0;
+var allowedTypes = ['wide', 'full-width'];
+var breakout = {
+  spanning: false,
+  inclusive: false,
+  parseDOM: [{
+    tag: 'div.fabric-editor-breakout-mark',
+    getAttrs: function getAttrs(dom) {
+      var mode = dom.getAttribute('data-mode');
+      return {
+        mode: allowedTypes.indexOf(mode || '') === -1 ? 'wide' : mode
+      };
+    }
+  }],
+  attrs: {
+    mode: {
+      default: 'wide'
+    }
+  },
+  toDOM: function toDOM(mark) {
+    return ['div', {
+      class: 'fabric-editor-breakout-mark',
+      'data-mode': mark.attrs.mode
+    }, 0];
+  }
+};
+exports.breakout = breakout;

package/dist/cjs/schema/marks/code.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.code = void 0;
+
+var _groups = require("../groups");
+
+var code = {
+  excludes: "".concat(_groups.FONT_STYLE, " ").concat(_groups.LINK, " ").concat(_groups.SEARCH_QUERY, " ").concat(_groups.COLOR),
+  inclusive: true,
+  parseDOM: [{
+    tag: 'span.code',
+    preserveWhitespace: true
+  }, {
+    tag: 'code',
+    preserveWhitespace: true
+  }, {
+    tag: 'tt',
+    preserveWhitespace: true
+  }, {
+    tag: 'span',
+    preserveWhitespace: true,
+    getAttrs: function getAttrs(domNode) {
+      var dom = domNode;
+
+      if (dom.style.whiteSpace === 'pre') {
+        return {};
+      }
+
+      if (dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf('monospace') >= 0) {
+        return {};
+      }
+
+      return false;
+    }
+  }],
+  toDOM: function toDOM() {
+    return ['span', {
+      class: 'code',
+      spellcheck: 'false'
+    }];
+  }
+};
+exports.code = code;

package/dist/cjs/schema/marks/confluence-inline-comment.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confluenceInlineComment = void 0;
+
+/**
+ * @name inline_comment_marker
+ * @description This temporary mark represents a Confluence-backed inline comment that wraps a piece of text. It will be replaced with a cross-product inline comment solution at later date.
+ */
+var confluenceInlineComment = {
+  inclusive: false,
+  excludes: '',
+  attrs: {
+    reference: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-mark-type="confluenceInlineComment"]'
+  }],
+  toDOM: function toDOM(node) {
+    return ['span', {
+      'data-mark-type': 'confluenceInlineComment',
+      'data-reference': node.attrs.reference
+    }];
+  }
+};
+exports.confluenceInlineComment = confluenceInlineComment;

package/dist/cjs/schema/marks/data-consumer.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJSON = exports.dataConsumer = void 0;
+
+var _parseDOM = require("../../utils/parseDOM");
+
+var parseDataConsumer = function parseDataConsumer(maybeValue) {
+  var sources = (0, _parseDOM.isDOMElement)(maybeValue) && maybeValue.getAttribute('data-sources');
+
+  try {
+    return sources ? {
+      sources: JSON.parse(sources)
+    } : false;
+  } catch (_unused) {
+    return false;
+  }
+};
+
+var dataConsumer = {
+  attrs: {
+    sources: {
+      default: []
+    }
+  },
+  parseDOM: [{
+    tag: '[data-mark-type="dataConsumer"]',
+    getAttrs: function getAttrs(maybeValue) {
+      return parseDataConsumer(maybeValue);
+    }
+  }],
+  toDOM: function toDOM(mark, inline) {
+    var wrapperStyle = inline ? 'span' : 'div';
+    return [wrapperStyle, {
+      'data-mark-type': 'dataConsumer',
+      'data-sources': JSON.stringify(mark.attrs.sources)
+    }];
+  }
+};
+/**
+ * We want to ensure any "invalid ADF" doesn't get serialised, but the entire
+ * mark itself is not valid without a non-empty `sources`.
+ *
+ * We _almost could_ simply return `null` if sources length is < 0 & would fit
+ * the type signature of prosemirror-model's `fragment` but not `mark`'s toJSON.
+ *
+ * So we'll leave any extra transformation checks in
+ * `editor-json-transformer`(?)
+ */
+
+exports.dataConsumer = dataConsumer;
+
+var toJSON = function toJSON(mark) {
+  // // Remove intemediary state if we don't have any sources on data consumer
+  // if (mark.attrs?.sources?.length < 1) {
+  //   return null;
+  // }
+  return {
+    type: mark.type.name,
+    attrs: Object.keys(mark.attrs).filter(function (key) {
+      return key === 'sources' && mark.attrs[key].length > 0 && mark.attrs[key] !== null;
+    }).reduce(function (acc, key) {
+      acc[key] = mark.attrs[key];
+      return acc;
+    }, {})
+  };
+};
+
+exports.toJSON = toJSON;