@atlaskit/adf-schema 19.2.0

package/dist/es2019/utils/confluence/emoji.js

@@ -0,0 +1,83 @@
+// Default emoji id for Confluence glyphs that has no match to Fabric Emoji
+const DEFAULT_EMOJI_ID = '2b50'; // Default ac:name for emoticons as a fallback is `blue-star`
+
+const DEFAULT_EMOJI_ACNAME = 'blue-star'; // ac:hipchat-emoticon prefix when converting to Emoji ID
+
+const HC_EMOTICON_PREFIX = 'atlassian-';
+/**
+ * Confluence glyphs ac:name of <ac:emoticon /> map to new emojis
+ * {
+ *   [ac:name] : ['emoji-id', 'emoji-shortName', 'emoji-fallback']
+ *   ...
+ * }
+ * Glyphs that do not map to Fabric Emoji
+ * will be mapped to Emoji Id '2b50' (:star:) with preserving ac:name as shortName attribute;
+ */
+
+const acNameToEmojiMap = {
+  smile: ['1f642', ':slight_smile:', '\uD83D\uDE42'],
+  sad: ['1f641', ':slight_frown:', '\uD83D\uDE41'],
+  cheeky: ['1f61b', ':stuck_out_tongue:', '\uD83D\uDE1B'],
+  laugh: ['1f600', ':grinning:', '\uD83D\uDE00'],
+  wink: ['1f609', ':wink:', '\uD83D\uDE09'],
+  information: ['2139', ':information_source:', '\u2139'],
+  tick: ['2705', ':white_check_mark:', '\u2705'],
+  cross: ['274c', ':x:', '\u274C'],
+  warning: ['26a0', ':warning:', '\u26A0'],
+  plus: ['2795', ':heavy_plus_sign:', '\u2795'],
+  minus: ['2796', ':heavy_minus_sign:', '\u2796'],
+  question: ['2753', ':question:', '\u003F'],
+  'thumbs-up': ['1f44d', ':thumbsup:', '\uD83D\uDC4D'],
+  'thumbs-down': ['1f44e', ':thumbsdown:', '\uD83D\uDC4E'],
+  'light-on': ['1f4a1', ':bulb:', '\uD83D\uDCA1'],
+  'yellow-star': ['2b50', ':star:', '\uD83D\uDC9B'],
+  'light-off': ['1f6ab', ':no_entry_sign:', '\uD83D\uDEAB'],
+  'red-star': ['2764', ':heart:', '\u2764\uFE0F'],
+  'green-star': ['1f49a', ':green_heart:', '\uD83D\uDC9A'],
+  'blue-star': ['1f499', ':blue_heart:', '\uD83D\uDC99'],
+  heart: ['2764', ':heart:', '\u2764\uFE0F'],
+  'broken-heart': ['1f494', ':broken_heart:', '\uD83D\uDC94']
+};
+export function acNameToEmoji(acName) {
+  const emojiData = acNameToEmojiMap[acName];
+  return emojiData ? {
+    id: emojiData[0],
+    shortName: emojiData[1],
+    text: emojiData[2]
+  } : {
+    id: DEFAULT_EMOJI_ID,
+    shortName: `:${acName}:`,
+    text: ''
+  };
+}
+export function emojiIdToAcName(emojiId) {
+  const filterEmojis = acName => acNameToEmojiMap[acName] ? acNameToEmojiMap[acName][0] === emojiId : false;
+
+  return Object.keys(acNameToEmojiMap).filter(filterEmojis)[0];
+}
+export function acShortcutToEmoji(hipchatEmoticonShortName) {
+  return {
+    id: `${HC_EMOTICON_PREFIX}${hipchatEmoticonShortName}`,
+    shortName: `:${hipchatEmoticonShortName}:`,
+    text: ''
+  };
+}
+
+function getAcNameFromShortName(shortName) {
+  return shortName.slice(shortName[0] === ':' ? 1 : 0, shortName[shortName.length - 1] === ':' ? -1 : shortName.length);
+}
+
+export function getEmojiAcName({
+  id,
+  shortName
+}) {
+  if (DEFAULT_EMOJI_ID === id) {
+    const possibleName = getAcNameFromShortName(shortName);
+
+    if (possibleName in acNameToEmojiMap) {
+      return possibleName;
+    }
+  }
+
+  return emojiIdToAcName(id) || DEFAULT_EMOJI_ACNAME;
+}

package/dist/es2019/utils/extensions.js

@@ -0,0 +1,26 @@
+export const isValidLayout = name => {
+  return !!name && ['default', 'wide', 'full-width'].includes(name);
+};
+export const getExtensionAttrs = (dom, isInline = false) => {
+  const extensionType = dom.getAttribute('data-extension-type');
+  const extensionKey = dom.getAttribute('data-extension-key');
+
+  if (!extensionType || !extensionKey) {
+    return false;
+  }
+
+  const attrs = {
+    extensionType,
+    extensionKey,
+    text: dom.getAttribute('data-text') || undefined,
+    parameters: JSON.parse(dom.getAttribute('data-parameters') || '{}'),
+    localId: dom.getAttribute('data-local-id') || undefined
+  };
+
+  if (!isInline) {
+    const rawLayout = dom.getAttribute('data-layout');
+    attrs.layout = isValidLayout(rawLayout) ? rawLayout : 'default';
+  }
+
+  return attrs;
+};

package/dist/es2019/utils/index.js

@@ -0,0 +1,4 @@
+export { acNameToEmoji, acShortcutToEmoji, emojiIdToAcName, getEmojiAcName } from './confluence/emoji';
+export { generateUuid, uuid } from './uuid';
+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, hexToRgb, hexToRgba, isHex, isRgb, normalizeHexColor, rgbToHex } from './colors';
+export { getLinkMatch, isSafeUrl, normalizeUrl } from './url';

package/dist/es2019/utils/parseDOM.js

@@ -0,0 +1 @@
+export const isDOMElement = maybeNode => maybeNode instanceof Node && maybeNode.nodeType === Node.ELEMENT_NODE;

package/dist/es2019/utils/url.js

@@ -0,0 +1,19 @@
+import LinkifyIt from 'linkify-it';
+const 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];
+export const isSafeUrl = url => {
+  return whitelistedURLPatterns.some(p => p.test(url.trim()) === true);
+};
+const linkify = LinkifyIt();
+linkify.add('sourcetree:', 'http:');
+export function getLinkMatch(str) {
+  const match = str && linkify.match(str);
+  return match && match[0];
+}
+/**
+ * Adds protocol to url if needed.
+ */
+
+export function normalizeUrl(url) {
+  const match = getLinkMatch(url);
+  return match && match.url || url;
+}

package/dist/es2019/utils/uuid.js

@@ -0,0 +1,18 @@
+/* eslint-disable no-bitwise */
+export const generateUuid = () => 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+  const r = Math.random() * 16 | 0;
+  return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+});
+/* eslint-enable no-bitwise */
+
+let staticValue = false;
+export const uuid = {
+  setStatic(value) {
+    staticValue = value;
+  },
+
+  generate() {
+    return staticValue || generateUuid();
+  }
+
+};

package/dist/es2019/version.json

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

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

@@ -0,0 +1,5 @@
+import { createSchema } from './create-schema';
+export var 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/esm/schema/confluence-schema.js

@@ -0,0 +1,11 @@
+import { createSchema } from './create-schema';
+var 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'];
+var marks = ['link', 'em', 'strong', 'strike', 'subsup', 'underline', 'mentionQuery', 'code', 'textColor', 'confluenceInlineComment', 'annotation', 'unsupportedMark', 'unsupportedNodeAttribute'];
+export var confluenceSchema = createSchema({
+  nodes: nodes,
+  marks: marks
+});
+export var confluenceSchemaWithMediaSingle = createSchema({
+  nodes: nodes.concat('mediaSingle'),
+  marks: marks
+});

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

@@ -0,0 +1,338 @@
+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 { 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) {
+  var customSpecs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  if (!config) {
+    return {};
+  }
+  /**
+   * Add built-in Node / Mark specs
+   */
+
+
+  var items = builtInItems.reduce(function (items, _ref) {
+    var name = _ref.name,
+        spec = _ref.spec;
+
+    if (config.indexOf(name) !== -1) {
+      items[name] = customSpecs[name] || spec;
+    }
+
+    return items;
+  }, {});
+  /**
+   * Add Custom Node / Mark specs
+   */
+
+  return Object.keys(customSpecs).reduce(function (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: "__".concat(name, "GroupDeclaration"),
+    spec: {
+      group: name
+    }
+  };
+}
+
+var markGroupDeclarations = [groupDeclaration(COLOR), groupDeclaration(FONT_STYLE), groupDeclaration(SEARCH_QUERY), groupDeclaration(LINK)];
+var markGroupDeclarationsNames = markGroupDeclarations.map(function (groupMark) {
+  return groupMark.name;
+});
+var 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
+}];
+var 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
+}].concat(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) {
+  var customNodeSpecs = config.customNodeSpecs,
+      customMarkSpecs = config.customMarkSpecs;
+  var nodesConfig = Object.keys(customNodeSpecs || {}).concat(config.nodes);
+  var marksConfig = Object.keys(customMarkSpecs || {}).concat(config.marks || []).concat(markGroupDeclarationsNames);
+  var nodes = addItems(nodesInOrder, nodesConfig, customNodeSpecs);
+  var marks = addItems(marksInOrder, marksConfig, customMarkSpecs);
+  nodes = sanitizeNodes(nodes, marks);
+  return new Schema({
+    nodes: nodes,
+    marks: marks
+  });
+}
+export function sanitizeNodes(nodes, supportedMarks) {
+  var nodeNames = Object.keys(nodes);
+  nodeNames.forEach(function (nodeKey) {
+    var nodeSpec = _objectSpread({}, nodes[nodeKey]);
+
+    if (nodeSpec.marks && nodeSpec.marks !== '_') {
+      nodeSpec.marks = nodeSpec.marks.split(' ').filter(function (mark) {
+        return !!supportedMarks[mark];
+      }).join(' ');
+    }
+
+    if (nodeSpec.content) {
+      nodeSpec.content = sanitizeNodeSpecContent(nodes, nodeSpec.content);
+    }
+
+    nodes[nodeKey] = nodeSpec;
+  });
+  return nodes;
+}
+export function sanitizeNodeSpecContent(nodes, rawContent) {
+  var content = rawContent.replace(/\W/g, ' ');
+  var contentKeys = content.split(' ');
+  var unsupportedContentKeys = contentKeys.filter(function (contentKey) {
+    return !isContentSupported(nodes, contentKey);
+  });
+  return unsupportedContentKeys.reduce(function (newContent, nodeName) {
+    return sanitizedContent(newContent, nodeName);
+  }, rawContent);
+}
+
+function sanitizedContent(content, invalidContent) {
+  if (!invalidContent.length) {
+    return content || '';
+  }
+
+  if (!content || !content.match(/\w/)) {
+    return '';
+  }
+
+  var pattern = "(".concat(invalidContent, "((\\s)*\\|)+)|((\\|(\\s)*)+").concat(invalidContent, ")|(").concat(invalidContent, "$)|(").concat(invalidContent, "(\\+|\\*))");
+  return content.replace(new RegExp(pattern, 'g'), '').replace('  ', ' ').trim();
+}
+
+function isContentSupported(nodes, contentKey) {
+  var nodeKeys = Object.keys(nodes); // content is with valid node
+
+  if (nodeKeys.indexOf(contentKey) > -1) {
+    return true;
+  } // content is with valid group
+
+
+  for (var supportedKey in nodes) {
+    var nodeSpec = nodes[supportedKey];
+
+    if (nodeSpec && nodeSpec.group === contentKey) {
+      return true;
+    }
+  }
+
+  return false;
+}