@atlaskit/adf-schema 19.2.0

package/dist/cjs/utils/parseDOM.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDOMElement = void 0;
+
+var isDOMElement = function isDOMElement(maybeNode) {
+  return maybeNode instanceof Node && maybeNode.nodeType === Node.ELEMENT_NODE;
+};
+
+exports.isDOMElement = isDOMElement;

package/dist/cjs/utils/url.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLinkMatch = getLinkMatch;
+exports.normalizeUrl = normalizeUrl;
+exports.isSafeUrl = void 0;
+
+var _linkifyIt = _interopRequireDefault(require("linkify-it"));
+
+var whitelistedURLPatterns = [/^https?:\/\//im, /^ftps?:\/\//im, /^\//im, /^mailto:/im, /^skype:/im, /^callto:/im, /^facetime:/im, /^git:/im, /^irc6?:/im, /^news:/im, /^nntp:/im, /^feed:/im, /^cvs:/im, /^svn:/im, /^mvn:/im, /^ssh:/im, /^scp:\/\//im, /^sftp:\/\//im, /^itms:/im, /^notes:/im, /^hipchat:\/\//im, /^sourcetree:/im, /^urn:/im, /^tel:/im, /^xmpp:/im, /^telnet:/im, /^vnc:/im, /^rdp:/im, /^whatsapp:/im, /^slack:/im, /^sips?:/im, /^magnet:/im, /^#/im];
+
+var isSafeUrl = function isSafeUrl(url) {
+  return whitelistedURLPatterns.some(function (p) {
+    return p.test(url.trim()) === true;
+  });
+};
+
+exports.isSafeUrl = isSafeUrl;
+var linkify = (0, _linkifyIt.default)();
+linkify.add('sourcetree:', 'http:');
+
+function getLinkMatch(str) {
+  var match = str && linkify.match(str);
+  return match && match[0];
+}
+/**
+ * Adds protocol to url if needed.
+ */
+
+
+function normalizeUrl(url) {
+  var match = getLinkMatch(url);
+  return match && match.url || url;
+}

package/dist/cjs/utils/uuid.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uuid = exports.generateUuid = void 0;
+
+/* eslint-disable no-bitwise */
+var generateUuid = function generateUuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = Math.random() * 16 | 0;
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+};
+/* eslint-enable no-bitwise */
+
+
+exports.generateUuid = generateUuid;
+var staticValue = false;
+var uuid = {
+  setStatic: function setStatic(value) {
+    staticValue = value;
+  },
+  generate: function generate() {
+    return staticValue || generateUuid();
+  }
+};
+exports.uuid = uuid;

package/dist/cjs/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/adf-schema",
+	"version": "19.2.0",
+	"sideEffects": false
+}

package/dist/es2019/index.js

@@ -0,0 +1,2 @@
+export { AnnotationTypes, PanelType, alignment, alignmentPositionMap, annotation, bitbucketSchema, blockCard, blockquote, bodiedExtension, breakout, bulletList, bulletListSelector, caption, code, codeBlock, codeBlockToJSON, colorPalette, colorPaletteExtended, confluenceInlineComment, confluenceJiraIssue, confluenceSchema, confluenceSchemaWithMediaSingle, confluenceUnsupportedBlock, confluenceUnsupportedInline, copyPrivateMediaAttributes, createJIRASchema, createSchema, dataConsumer, dataConsumerToJSON, date, decisionItem, decisionList, decisionListSelector, defaultSchema, defaultSchemaConfig, doc, em, embedCard, emoji, expand, expandToJSON, extension, getSchemaBasedOnStage, hardBreak, heading, image, indentation, inlineCard, inlineExtension, inlineNodes, isSchemaWithAdvancedTextFormattingMarks, isSchemaWithBlockQuotes, isSchemaWithCodeBlock, isSchemaWithEmojis, isSchemaWithLinks, isSchemaWithLists, isSchemaWithMedia, isSchemaWithMentions, isSchemaWithSubSupMark, isSchemaWithTables, isSchemaWithTextColor, layoutColumn, layoutSection, link, linkToJSON, listItem, media, mediaGroup, mediaSingle, mediaSingleWithCaption, mediaInline, mediaSingleToJSON, mediaToJSON, mention, mentionToJSON, nestedExpand, orderedList, orderedListSelector, panel, customPanel, paragraph, placeholder, rule, sanitizeNodes, getCellAttrs, getCellDomAttrs, status, strike, strong, subsup, table, tableBackgroundBorderColor, tableBackgroundColorNames, tableBackgroundColorPalette, tableCell, tableCellContentDomSelector, tableCellContentWrapperSelector, tableCellSelector, tableHeader, tableHeaderSelector, tablePrefixSelector, tableRow, tableToJSON, taskItem, taskList, taskListSelector, text, textColor, toJSONTableCell, toJSONTableHeader, typeAheadQuery, underline, unknownBlock, unsupportedBlock, unsupportedInline, unsupportedNodeTypesForMediaCards, buildAnnotationMarkDataAttributes, AnnotationMarkStates, unsupportedMark, unsupportedNodeAttribute } from './schema';
+export { B100, B400, B50, B500, B75, G200, G300, G400, G50, G500, G75, N0, N20, N200, N30, N300, N40, N50, N500, N60, N80, N800, N90, P100, P300, P400, P50, P500, P75, R100, R300, R400, R50, R500, R75, T100, T300, T50, T500, T75, Y200, Y400, Y50, Y500, Y75, acNameToEmoji, acShortcutToEmoji, emojiIdToAcName, generateUuid, getEmojiAcName, getLinkMatch, hexToRgb, hexToRgba, isHex, isRgb, isSafeUrl, normalizeHexColor, normalizeUrl, rgbToHex, uuid } from './utils';

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

@@ -0,0 +1,5 @@
+import { createSchema } from './create-schema';
+export const bitbucketSchema = createSchema({
+  nodes: ['doc', 'caption', 'paragraph', 'text', 'bulletList', 'orderedList', 'listItem', 'heading', 'blockquote', 'codeBlock', 'hardBreak', 'rule', 'image', 'media', 'mediaSingle', 'mention', 'emoji', 'table', 'tableCell', 'tableHeader', 'tableRow', 'inlineCard', 'unsupportedBlock', 'unsupportedInline'],
+  marks: ['em', 'strong', 'strike', 'link', 'code', 'unsupportedMark', 'unsupportedNodeAttribute']
+});

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

@@ -0,0 +1,11 @@
+import { createSchema } from './create-schema';
+const nodes = ['doc', 'paragraph', 'blockquote', 'codeBlock', 'panel', 'hardBreak', 'orderedList', 'bulletList', 'heading', 'mediaGroup', 'mediaSingle', 'media', 'caption', 'confluenceUnsupportedBlock', 'confluenceJiraIssue', 'expand', 'nestedExpand', 'extension', 'inlineExtension', 'bodiedExtension', 'listItem', 'mention', 'text', 'confluenceUnsupportedInline', 'media', 'rule', 'table', 'tableCell', 'tableHeader', 'tableRow', 'emoji', 'taskList', 'taskItem', 'date', 'placeholder', 'decisionList', 'decisionItem', 'layoutSection', 'layoutColumn', 'inlineCard', 'unsupportedBlock', 'unsupportedInline'];
+const marks = ['link', 'em', 'strong', 'strike', 'subsup', 'underline', 'mentionQuery', 'code', 'textColor', 'confluenceInlineComment', 'annotation', 'unsupportedMark', 'unsupportedNodeAttribute'];
+export const confluenceSchema = createSchema({
+  nodes,
+  marks
+});
+export const confluenceSchemaWithMediaSingle = createSchema({
+  nodes: nodes.concat('mediaSingle'),
+  marks
+});

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

@@ -0,0 +1,325 @@
+import { Schema } from 'prosemirror-model';
+import { COLOR, FONT_STYLE, SEARCH_QUERY, LINK } from './groups';
+import { link, em, strong, textColor, strike, subsup, underline, code, typeAheadQuery, confluenceInlineComment, breakout, alignment, indentation, annotation, unsupportedMark, unsupportedNodeAttribute, dataConsumer } from './marks';
+import { confluenceJiraIssue, confluenceUnsupportedBlock, confluenceUnsupportedInline, doc, paragraph, text, bulletList, orderedList, listItem, heading, blockquote, codeBlock, panel, rule, image, mention, media, mediaInline, mediaGroup, mediaSingle, hardBreak, emoji, table, tableCell, tableHeader, tableRow, decisionList, decisionItem, taskList, taskItem, unknownBlock, extension, inlineExtension, bodiedExtension, date, placeholder, layoutSection, layoutColumn, inlineCard, blockCard, unsupportedBlock, unsupportedInline, status, expand, nestedExpand, embedCard, caption } from './nodes';
+
+function addItems(builtInItems, config, customSpecs = {}) {
+  if (!config) {
+    return {};
+  }
+  /**
+   * Add built-in Node / Mark specs
+   */
+
+
+  const items = builtInItems.reduce((items, {
+    name,
+    spec
+  }) => {
+    if (config.indexOf(name) !== -1) {
+      items[name] = customSpecs[name] || spec;
+    }
+
+    return items;
+  }, {});
+  /**
+   * Add Custom Node / Mark specs
+   */
+
+  return Object.keys(customSpecs).reduce((items, name) => {
+    if (items[name]) {
+      return items;
+    }
+
+    items[name] = customSpecs[name];
+    return items;
+  }, items);
+} // We use groups to allow schemas to be constructed in different shapes without changing node/mark
+// specs, but this means nodes/marks are defined with groups that might never be used in the schema.
+// In this scenario ProseMirror will complain and prevent the schema from being constructed.
+//
+// To avoid the problem, we include items that serve to "declare" the groups in the schema. This
+// approach unfortunately leaves unused items in the schema, but has the benefit of avoiding the
+// need to manipulate `exclude` or content expression values for potentially every schema item.
+
+
+function groupDeclaration(name) {
+  return {
+    name: `__${name}GroupDeclaration`,
+    spec: {
+      group: name
+    }
+  };
+}
+
+const markGroupDeclarations = [groupDeclaration(COLOR), groupDeclaration(FONT_STYLE), groupDeclaration(SEARCH_QUERY), groupDeclaration(LINK)];
+const markGroupDeclarationsNames = markGroupDeclarations.map(groupMark => groupMark.name);
+const nodesInOrder = [{
+  name: 'doc',
+  spec: doc
+}, {
+  name: 'paragraph',
+  spec: paragraph
+}, {
+  name: 'text',
+  spec: text
+}, {
+  name: 'bulletList',
+  spec: bulletList
+}, {
+  name: 'orderedList',
+  spec: orderedList
+}, {
+  name: 'listItem',
+  spec: listItem
+}, {
+  name: 'heading',
+  spec: heading
+}, {
+  name: 'blockquote',
+  spec: blockquote
+}, {
+  name: 'codeBlock',
+  spec: codeBlock
+}, {
+  name: 'panel',
+  spec: panel
+}, {
+  name: 'rule',
+  spec: rule
+}, {
+  name: 'image',
+  spec: image
+}, {
+  name: 'mention',
+  spec: mention
+}, {
+  name: 'caption',
+  spec: caption
+}, {
+  name: 'media',
+  spec: media
+}, {
+  name: 'mediaGroup',
+  spec: mediaGroup
+}, {
+  name: 'mediaSingle',
+  spec: mediaSingle
+}, {
+  name: 'mediaInline',
+  spec: mediaInline
+}, {
+  name: 'placeholder',
+  spec: placeholder
+}, {
+  name: 'layoutSection',
+  spec: layoutSection
+}, {
+  name: 'layoutColumn',
+  spec: layoutColumn
+}, {
+  name: 'hardBreak',
+  spec: hardBreak
+}, {
+  name: 'emoji',
+  spec: emoji
+}, {
+  name: 'table',
+  spec: table
+}, {
+  name: 'tableCell',
+  spec: tableCell
+}, {
+  name: 'tableRow',
+  spec: tableRow
+}, {
+  name: 'tableHeader',
+  spec: tableHeader
+}, {
+  name: 'confluenceJiraIssue',
+  spec: confluenceJiraIssue
+}, {
+  name: 'confluenceUnsupportedInline',
+  spec: confluenceUnsupportedInline
+}, {
+  name: 'confluenceUnsupportedBlock',
+  spec: confluenceUnsupportedBlock
+}, {
+  name: 'decisionList',
+  spec: decisionList
+}, {
+  name: 'decisionItem',
+  spec: decisionItem
+}, {
+  name: 'taskList',
+  spec: taskList
+}, {
+  name: 'taskItem',
+  spec: taskItem
+}, {
+  name: 'date',
+  spec: date
+}, {
+  name: 'status',
+  spec: status
+}, {
+  name: 'expand',
+  spec: expand
+}, {
+  name: 'nestedExpand',
+  spec: nestedExpand
+}, {
+  name: 'extension',
+  spec: extension
+}, {
+  name: 'inlineExtension',
+  spec: inlineExtension
+}, {
+  name: 'bodiedExtension',
+  spec: bodiedExtension
+}, {
+  name: 'inlineCard',
+  spec: inlineCard
+}, {
+  name: 'blockCard',
+  spec: blockCard
+}, {
+  name: 'embedCard',
+  spec: embedCard
+}, {
+  name: 'unknownBlock',
+  spec: unknownBlock
+}, {
+  name: 'unsupportedBlock',
+  spec: unsupportedBlock
+}, {
+  name: 'unsupportedInline',
+  spec: unsupportedInline
+}];
+const marksInOrder = [{
+  name: 'link',
+  spec: link
+}, {
+  name: 'em',
+  spec: em
+}, {
+  name: 'strong',
+  spec: strong
+}, {
+  name: 'textColor',
+  spec: textColor
+}, {
+  name: 'strike',
+  spec: strike
+}, {
+  name: 'subsup',
+  spec: subsup
+}, {
+  name: 'underline',
+  spec: underline
+}, {
+  name: 'code',
+  spec: code
+}, {
+  name: 'typeAheadQuery',
+  spec: typeAheadQuery
+}, {
+  name: 'alignment',
+  spec: alignment
+}, {
+  name: 'annotation',
+  spec: annotation
+}, {
+  name: 'confluenceInlineComment',
+  spec: confluenceInlineComment
+}, ...markGroupDeclarations, {
+  name: 'breakout',
+  spec: breakout
+}, {
+  name: 'dataConsumer',
+  spec: dataConsumer
+}, {
+  name: 'indentation',
+  spec: indentation
+}, {
+  name: 'unsupportedMark',
+  spec: unsupportedMark
+}, {
+  name: 'unsupportedNodeAttribute',
+  spec: unsupportedNodeAttribute
+}];
+/**
+ * Creates a schema preserving order of marks and nodes.
+ */
+
+export function createSchema(config) {
+  const {
+    customNodeSpecs,
+    customMarkSpecs
+  } = config;
+  const nodesConfig = Object.keys(customNodeSpecs || {}).concat(config.nodes);
+  const marksConfig = Object.keys(customMarkSpecs || {}).concat(config.marks || []).concat(markGroupDeclarationsNames);
+  let nodes = addItems(nodesInOrder, nodesConfig, customNodeSpecs);
+  let marks = addItems(marksInOrder, marksConfig, customMarkSpecs);
+  nodes = sanitizeNodes(nodes, marks);
+  return new Schema({
+    nodes,
+    marks
+  });
+}
+export function sanitizeNodes(nodes, supportedMarks) {
+  const nodeNames = Object.keys(nodes);
+  nodeNames.forEach(nodeKey => {
+    const nodeSpec = { ...nodes[nodeKey]
+    };
+
+    if (nodeSpec.marks && nodeSpec.marks !== '_') {
+      nodeSpec.marks = nodeSpec.marks.split(' ').filter(mark => !!supportedMarks[mark]).join(' ');
+    }
+
+    if (nodeSpec.content) {
+      nodeSpec.content = sanitizeNodeSpecContent(nodes, nodeSpec.content);
+    }
+
+    nodes[nodeKey] = nodeSpec;
+  });
+  return nodes;
+}
+export function sanitizeNodeSpecContent(nodes, rawContent) {
+  const content = rawContent.replace(/\W/g, ' ');
+  const contentKeys = content.split(' ');
+  const unsupportedContentKeys = contentKeys.filter(contentKey => !isContentSupported(nodes, contentKey));
+  return unsupportedContentKeys.reduce((newContent, nodeName) => sanitizedContent(newContent, nodeName), rawContent);
+}
+
+function sanitizedContent(content, invalidContent) {
+  if (!invalidContent.length) {
+    return content || '';
+  }
+
+  if (!content || !content.match(/\w/)) {
+    return '';
+  }
+
+  const pattern = `(${invalidContent}((\\s)*\\|)+)|((\\|(\\s)*)+${invalidContent})|(${invalidContent}$)|(${invalidContent}(\\+|\\*))`;
+  return content.replace(new RegExp(pattern, 'g'), '').replace('  ', ' ').trim();
+}
+
+function isContentSupported(nodes, contentKey) {
+  const nodeKeys = Object.keys(nodes); // content is with valid node
+
+  if (nodeKeys.indexOf(contentKey) > -1) {
+    return true;
+  } // content is with valid group
+
+
+  for (const supportedKey in nodes) {
+    const nodeSpec = nodes[supportedKey];
+
+    if (nodeSpec && nodeSpec.group === contentKey) {
+      return true;
+    }
+  }
+
+  return false;
+}

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

@@ -0,0 +1,35 @@
+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';
+
+const getDefaultSchemaConfig = () => {
+  let 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 const defaultSchemaConfig = getDefaultSchemaConfig();
+export const getSchemaBasedOnStage = (stage = 'final') => {
+  const 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 const defaultSchema = getSchemaBasedOnStage();