@atlaskit/adf-schema 19.2.0

package/dist/esm/schema/default-schema.js

@@ -0,0 +1,36 @@
+import { customPanel } from './nodes/panel';
+import { layoutSectionWithSingleColumn } from './nodes/layout-section';
+import { dataConsumer } from './marks/data-consumer';
+import { createSchema } from './create-schema';
+import { mediaSingleWithCaption } from './nodes';
+
+var getDefaultSchemaConfig = function getDefaultSchemaConfig() {
+  var defaultSchemaConfig = {
+    nodes: ['doc', 'paragraph', 'text', 'bulletList', 'orderedList', 'listItem', 'heading', 'blockquote', 'codeBlock', 'panel', 'rule', 'image', 'mention', 'media', 'mediaGroup', 'mediaSingle', 'mediaInline', 'confluenceUnsupportedBlock', 'confluenceUnsupportedInline', 'confluenceJiraIssue', 'expand', 'nestedExpand', 'extension', 'inlineExtension', 'bodiedExtension', 'hardBreak', 'emoji', 'table', 'tableCell', 'tableHeader', 'tableRow', 'decisionList', 'decisionItem', 'taskList', 'taskItem', 'unknownBlock', 'date', 'status', 'placeholder', 'layoutSection', 'layoutColumn', 'inlineCard', 'blockCard', 'embedCard', 'unsupportedBlock', 'unsupportedInline'],
+    marks: ['link', 'em', 'strong', 'strike', 'subsup', 'underline', 'code', 'textColor', 'confluenceInlineComment', 'breakout', 'alignment', 'indentation', 'annotation', 'unsupportedMark', 'unsupportedNodeAttribute', 'typeAheadQuery' // https://product-fabric.atlassian.net/browse/ED-10214,
+    ]
+  };
+  return defaultSchemaConfig;
+};
+
+export var defaultSchemaConfig = getDefaultSchemaConfig();
+export var getSchemaBasedOnStage = function getSchemaBasedOnStage() {
+  var stage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'final';
+  var defaultSchemaConfig = getDefaultSchemaConfig(); // TODO: ED-10445 remove stage0 check after panels with emoji are on full schema AND image captions are on full schema
+
+  if (stage === 'stage0') {
+    defaultSchemaConfig.customNodeSpecs = {
+      panel: customPanel,
+      mediaSingle: mediaSingleWithCaption,
+      layoutSection: layoutSectionWithSingleColumn
+    };
+    defaultSchemaConfig.customMarkSpecs = {
+      dataConsumer: dataConsumer
+    };
+    defaultSchemaConfig.nodes.push('caption');
+    defaultSchemaConfig.nodes.push('mediaInline');
+  }
+
+  return createSchema(defaultSchemaConfig);
+};
+export var defaultSchema = getSchemaBasedOnStage();

package/dist/esm/schema/groups.js

@@ -0,0 +1,23 @@
+// # What do marks exist?
+//
+// Marks are categorised into different groups. One motivation for this was to allow the `code` mark
+// to exclude other marks, without needing to explicitly name them. Explicit naming requires the
+// named mark to exist in the schema. This is undesirable because we want to construct different
+// schemas that have different sets of nodes/marks.
+//
+// Groups provide a level of indirection, and solve this problem. For the immediate use-case, one
+// group called "not_code" would have sufficed, but this an ultra-specialised to code.
+// Mark group for font styling (e.g. bold, italic, underline, superscript).
+export var FONT_STYLE = 'fontStyle'; // Marks group for search queries.
+
+export var SEARCH_QUERY = 'searchQuery'; // Marks group for links.
+
+export var LINK = 'link'; // Marks group for colors (text-color, background-color, etc).
+
+export var COLOR = 'color'; // They need to be on their own group so that they can exclude each other
+// and also work when one of them is disabled.
+// Marks group for alignment.
+
+export var ALIGNMENT = 'alignment'; // Marks group for indentation.
+
+export var INDENTATION = 'indentation';

package/dist/esm/schema/index.js

@@ -0,0 +1,9 @@
+export { PanelType, blockCard, blockquote, bodiedExtension, bulletList, bulletListSelector, caption, codeBlock, codeBlockToJSON, confluenceJiraIssue, confluenceUnsupportedBlock, confluenceUnsupportedInline, copyPrivateMediaAttributes, date, decisionItem, decisionList, decisionListSelector, doc, embedCard, emoji, expand, expandToJSON, extension, hardBreak, heading, image, inlineCard, inlineExtension, layoutColumn, layoutSection, layoutSectionWithSingleColumn, listItem, media, mediaGroup, mediaSingle, mediaInline, mediaSingleWithCaption, mediaSingleToJSON, mediaToJSON, mention, mentionToJSON, nestedExpand, orderedList, orderedListSelector, panel, customPanel, paragraph, placeholder, rule, getCellAttrs, getCellDomAttrs, status, table, tableBackgroundBorderColor, tableBackgroundColorNames, tableBackgroundColorPalette, tableCell, tableCellContentDomSelector, tableCellContentWrapperSelector, tableCellSelector, tableHeader, tableHeaderSelector, tablePrefixSelector, tableRow, tableToJSON, taskItem, taskList, taskListSelector, text, toJSONTableCell, toJSONTableHeader, unknownBlock, unsupportedBlock, unsupportedInline } from './nodes';
+export { AnnotationTypes, alignment, alignmentPositionMap, annotation, breakout, code, colorPalette, colorPaletteExtended, confluenceInlineComment, dataConsumer, dataConsumerToJSON, em, indentation, link, linkToJSON, strike, strong, subsup, textColor, typeAheadQuery, underline, buildAnnotationMarkDataAttributes, AnnotationMarkStates, unsupportedMark, unsupportedNodeAttribute } from './marks';
+export { unsupportedNodeTypesForMediaCards } from './unsupported';
+export { inlineNodes } from './inline-nodes';
+export { sanitizeNodes, createSchema } from './create-schema';
+export { bitbucketSchema } from './bitbucket-schema';
+export { confluenceSchema, confluenceSchemaWithMediaSingle } from './confluence-schema';
+export { defaultSchema, getSchemaBasedOnStage, defaultSchemaConfig } from './default-schema';
+export { default as createJIRASchema, isSchemaWithLists, isSchemaWithMentions, isSchemaWithEmojis, isSchemaWithLinks, isSchemaWithAdvancedTextFormattingMarks, isSchemaWithCodeBlock, isSchemaWithBlockQuotes, isSchemaWithMedia, isSchemaWithSubSupMark, isSchemaWithTextColor, isSchemaWithTables } from './jira-schema';

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

@@ -0,0 +1,5 @@
+import * as nodes from './nodes';
+var typedNodes = nodes;
+export var inlineNodes = new Set(Object.keys(typedNodes).filter(function (key) {
+  return typedNodes[key] && typedNodes[key].group === 'inline';
+}));

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

@@ -0,0 +1,88 @@
+import { createSchema } from './create-schema';
+export default 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 createSchema({
+    nodes: nodes,
+    marks: marks
+  });
+}
+export function isSchemaWithLists(schema) {
+  return !!schema.nodes.bulletList;
+}
+export function isSchemaWithMentions(schema) {
+  return !!schema.nodes.mention;
+}
+export function isSchemaWithEmojis(schema) {
+  return !!schema.nodes.emoji;
+}
+export function isSchemaWithLinks(schema) {
+  return !!schema.marks.link;
+}
+export function isSchemaWithAdvancedTextFormattingMarks(schema) {
+  return !!schema.marks.code && !!schema.marks.strike;
+}
+export function isSchemaWithSubSupMark(schema) {
+  return !!schema.marks.subsup;
+}
+export function isSchemaWithCodeBlock(schema) {
+  return !!schema.nodes.codeBlock;
+}
+export function isSchemaWithBlockQuotes(schema) {
+  return !!schema.nodes.blockquote;
+}
+export function isSchemaWithMedia(schema) {
+  return !!schema.nodes.mediaGroup && !!schema.nodes.media;
+}
+export function isSchemaWithTextColor(schema) {
+  return !!schema.marks.textColor;
+}
+export function isSchemaWithTables(schema) {
+  return !!schema.nodes.table && !!schema.nodes.tableCell && !!schema.nodes.tableHeader && !!schema.nodes.tableRow;
+}

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

@@ -0,0 +1,30 @@
+import { ALIGNMENT, INDENTATION } from '../groups';
+/** TODO: Flip these positions for RTL */
+
+export var alignmentPositionMap = {
+  end: 'right',
+  right: 'end',
+  center: 'center'
+};
+export var alignment = {
+  excludes: "alignment ".concat(INDENTATION),
+  group: 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];
+  }
+};

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

@@ -0,0 +1,82 @@
+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; }
+
+/**
+ * @name annotation_mark
+ */
+export var AnnotationTypes;
+
+(function (AnnotationTypes) {
+  AnnotationTypes["INLINE_COMMENT"] = "inlineComment";
+})(AnnotationTypes || (AnnotationTypes = {}));
+
+export var AnnotationMarkStates;
+
+(function (AnnotationMarkStates) {
+  AnnotationMarkStates["RESOLVED"] = "resolved";
+  AnnotationMarkStates["ACTIVE"] = "active";
+})(AnnotationMarkStates || (AnnotationMarkStates = {}));
+
+export 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;
+}
+export 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];
+  }
+};

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

@@ -0,0 +1,25 @@
+var allowedTypes = ['wide', 'full-width'];
+export 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];
+  }
+};

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

@@ -0,0 +1,41 @@
+import { COLOR, FONT_STYLE, LINK, SEARCH_QUERY } from '../groups';
+/**
+ * @name code_mark
+ */
+
+export var code = {
+  excludes: "".concat(FONT_STYLE, " ").concat(LINK, " ").concat(SEARCH_QUERY, " ").concat(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'
+    }];
+  }
+};

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

@@ -0,0 +1,22 @@
+/**
+ * @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.
+ */
+export 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
+    }];
+  }
+};

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

@@ -0,0 +1,63 @@
+import { isDOMElement } from '../../utils/parseDOM';
+/**
+ * @minLength 1
+ */
+
+var parseDataConsumer = function parseDataConsumer(maybeValue) {
+  var sources = isDOMElement(maybeValue) && maybeValue.getAttribute('data-sources');
+
+  try {
+    return sources ? {
+      sources: JSON.parse(sources)
+    } : false;
+  } catch (_unused) {
+    return false;
+  }
+};
+
+export 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`(?)
+ */
+
+export 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;
+    }, {})
+  };
+};

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

@@ -0,0 +1,20 @@
+import { FONT_STYLE } from '../groups';
+/**
+ * @name em_mark
+ */
+
+var emDOM = ['em'];
+export var em = {
+  inclusive: true,
+  group: FONT_STYLE,
+  parseDOM: [{
+    tag: 'i'
+  }, {
+    tag: 'em'
+  }, {
+    style: 'font-style=italic'
+  }],
+  toDOM: function toDOM() {
+    return emDOM;
+  }
+};