@atlaskit/adf-schema 19.2.0

package/dist/es2019/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 const FONT_STYLE = 'fontStyle'; // Marks group for search queries.
+
+export const SEARCH_QUERY = 'searchQuery'; // Marks group for links.
+
+export const LINK = 'link'; // Marks group for colors (text-color, background-color, etc).
+
+export const 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 const ALIGNMENT = 'alignment'; // Marks group for indentation.
+
+export const INDENTATION = 'indentation';

package/dist/es2019/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/es2019/schema/inline-nodes.js

@@ -0,0 +1,3 @@
+import * as nodes from './nodes';
+const typedNodes = nodes;
+export const inlineNodes = new Set(Object.keys(typedNodes).filter(key => typedNodes[key] && typedNodes[key].group === 'inline'));

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

@@ -0,0 +1,88 @@
+import { createSchema } from './create-schema';
+export default function makeSchema(config) {
+  const nodes = ['doc', 'paragraph', 'text', 'hardBreak', 'heading', 'rule'];
+  const 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,
+    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/es2019/schema/marks/alignment.js

@@ -0,0 +1,32 @@
+import { ALIGNMENT, INDENTATION } from '../groups';
+/** TODO: Flip these positions for RTL */
+
+export const alignmentPositionMap = {
+  end: 'right',
+  right: 'end',
+  center: 'center'
+};
+export const alignment = {
+  excludes: `alignment ${INDENTATION}`,
+  group: ALIGNMENT,
+  attrs: {
+    align: {}
+  },
+  parseDOM: [{
+    tag: 'div.fabric-editor-block-mark',
+    getAttrs: dom => {
+      const align = dom.getAttribute('data-align');
+      return align ? {
+        align
+      } : false;
+    }
+  }],
+
+  toDOM(mark) {
+    return ['div', {
+      class: `fabric-editor-block-mark fabric-editor-align-${mark.attrs.align}`,
+      'data-align': mark.attrs.align
+    }, 0];
+  }
+
+};

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

@@ -0,0 +1,80 @@
+/**
+ * @name annotation_mark
+ */
+export let AnnotationTypes;
+
+(function (AnnotationTypes) {
+  AnnotationTypes["INLINE_COMMENT"] = "inlineComment";
+})(AnnotationTypes || (AnnotationTypes = {}));
+
+export let AnnotationMarkStates;
+
+(function (AnnotationMarkStates) {
+  AnnotationMarkStates["RESOLVED"] = "resolved";
+  AnnotationMarkStates["ACTIVE"] = "active";
+})(AnnotationMarkStates || (AnnotationMarkStates = {}));
+
+export function buildDataAttributes({
+  id,
+  annotationType,
+  state
+}) {
+  const data = {
+    'data-mark-type': 'annotation',
+    'data-mark-annotation-type': annotationType,
+    'data-id': id
+  };
+
+  if (state) {
+    return { ...data,
+      'data-mark-annotation-state': state
+    };
+  }
+
+  return data;
+}
+export const annotation = {
+  inclusive: false,
+  group: 'annotation',
+  excludes: '',
+  attrs: {
+    id: {
+      default: ''
+    },
+    annotationType: {
+      default: AnnotationTypes.INLINE_COMMENT
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-mark-type="annotation"]',
+    mark: 'annotation',
+    getAttrs: domNode => {
+      const dom = domNode;
+      let attrs = {
+        id: dom.getAttribute('data-id'),
+        annotationType: dom.getAttribute('data-mark-annotation-type')
+      };
+      return attrs;
+    }
+  }],
+
+  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', {
+      // 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/es2019/schema/marks/breakout.js

@@ -0,0 +1,29 @@
+const allowedTypes = ['wide', 'full-width'];
+export const breakout = {
+  spanning: false,
+  inclusive: false,
+  parseDOM: [{
+    tag: 'div.fabric-editor-breakout-mark',
+
+    getAttrs(dom) {
+      const mode = dom.getAttribute('data-mode');
+      return {
+        mode: allowedTypes.indexOf(mode || '') === -1 ? 'wide' : mode
+      };
+    }
+
+  }],
+  attrs: {
+    mode: {
+      default: 'wide'
+    }
+  },
+
+  toDOM(mark) {
+    return ['div', {
+      class: 'fabric-editor-breakout-mark',
+      'data-mode': mark.attrs.mode
+    }, 0];
+  }
+
+};

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

@@ -0,0 +1,43 @@
+import { COLOR, FONT_STYLE, LINK, SEARCH_QUERY } from '../groups';
+/**
+ * @name code_mark
+ */
+
+export const code = {
+  excludes: `${FONT_STYLE} ${LINK} ${SEARCH_QUERY} ${COLOR}`,
+  inclusive: true,
+  parseDOM: [{
+    tag: 'span.code',
+    preserveWhitespace: true
+  }, {
+    tag: 'code',
+    preserveWhitespace: true
+  }, {
+    tag: 'tt',
+    preserveWhitespace: true
+  }, {
+    tag: 'span',
+    preserveWhitespace: true,
+    getAttrs: domNode => {
+      let dom = domNode;
+
+      if (dom.style.whiteSpace === 'pre') {
+        return {};
+      }
+
+      if (dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf('monospace') >= 0) {
+        return {};
+      }
+
+      return false;
+    }
+  }],
+
+  toDOM() {
+    return ['span', {
+      class: 'code',
+      spellcheck: 'false'
+    }];
+  }
+
+};

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

@@ -0,0 +1,24 @@
+/**
+ * @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 const confluenceInlineComment = {
+  inclusive: false,
+  excludes: '',
+  attrs: {
+    reference: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: 'span[data-mark-type="confluenceInlineComment"]'
+  }],
+
+  toDOM(node) {
+    return ['span', {
+      'data-mark-type': 'confluenceInlineComment',
+      'data-reference': node.attrs.reference
+    }];
+  }
+
+};

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

@@ -0,0 +1,61 @@
+import { isDOMElement } from '../../utils/parseDOM';
+/**
+ * @minLength 1
+ */
+
+const parseDataConsumer = maybeValue => {
+  const sources = isDOMElement(maybeValue) && maybeValue.getAttribute('data-sources');
+
+  try {
+    return sources ? {
+      sources: JSON.parse(sources)
+    } : false;
+  } catch {
+    return false;
+  }
+};
+
+export const dataConsumer = {
+  attrs: {
+    sources: {
+      default: []
+    }
+  },
+  parseDOM: [{
+    tag: '[data-mark-type="dataConsumer"]',
+    getAttrs: maybeValue => parseDataConsumer(maybeValue)
+  }],
+
+  toDOM(mark, inline) {
+    const 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 const 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(key => key === 'sources' && mark.attrs[key].length > 0 && mark.attrs[key] !== null).reduce((acc, key) => {
+      acc[key] = mark.attrs[key];
+      return acc;
+    }, {})
+  };
+};

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

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

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

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